opcodes/rx-decode.c

   1 #line 1 "rx-decode.opc"
   2 /* -*- c -*- */
   3 /* Copyright (C) 2012-2017 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 #include "libiberty.h"
  31
  32 #define RX_OPCODE_BIG_ENDIAN 0
  33
  34 typedef struct
  35 {
  36   RX_Opcode_Decoded * rx;
  37   int (* getbyte)(void *);
  38   void * ptr;
  39   unsigned char * op;
  40 } LocalData;
  41
  42 static int trace = 0;
  43
  44 #define BSIZE 0
  45 #define WSIZE 1
  46 #define LSIZE 2
  47
  48 /* These are for when the upper bits are "don't care" or "undefined".  */
  49 static int bwl[4] =
  50 {
  51   RX_Byte,
  52   RX_Word,
  53   RX_Long,
  54   RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
  55 };
  56
  57 static int sbwl[4] =
  58 {
  59   RX_SByte,
  60   RX_SWord,
  61   RX_Long,
  62   RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
  63 };
  64
  65 static int ubw[4] =
  66 {
  67   RX_UByte,
  68   RX_UWord,
  69   RX_Bad_Size,/* Bogus instructions can have a size field set to 2.  */
  70   RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
  71 };
  72
  73 static int memex[4] =
  74 {
  75   RX_SByte,
  76   RX_SWord,
  77   RX_Long,
  78   RX_UWord
  79 };
  80
  81 #define ID(x) rx->id = RXO_##x
  82 #define OP(n,t,r,a) (rx->op[n].type = t, \
  83                      rx->op[n].reg = r,      \
  84                      rx->op[n].addend = a )
  85 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
  86                         rx->op[n].size = s )
  87
  88 /* This is for the BWL and BW bitfields.  */
  89 static int SCALE[] = { 1, 2, 4, 0 };
  90 /* This is for the prefix size enum.  */
  91 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
  92
  93 #define GET_SCALE(_indx)  ((unsigned)(_indx) < ARRAY_SIZE (SCALE) ? SCALE[(_indx)] : 0)
  94 #define GET_PSCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (PSCALE) ? PSCALE[(_indx)] : 0)
  95
  96 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
  97                        16, 17, 0, 0, 0, 0, 0, 0 };
  98
  99 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
 100
 101 /*
 102  *C     a constant (immediate) c
 103  *R     A register
 104  *I     Register indirect, no offset
 105  *Is    Register indirect, with offset
 106  *D     standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
 107  *P     standard displacement: type (r,[r]), reg, assumes UByte
 108  *Pm    memex displacement: type (r,[r]), reg, memex code
 109  *cc    condition code.  */
 110
 111 #define DC(c)       OP (0, RX_Operand_Immediate, 0, c)
 112 #define DR(r)       OP (0, RX_Operand_Register,  r, 0)
 113 #define DI(r,a)     OP (0, RX_Operand_Indirect,  r, a)
 114 #define DIs(r,a,s)  OP (0, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))
 115 #define DD(t,r,s)   rx_disp (0, t, r, bwl[s], ld);
 116 #define DF(r)       OP (0, RX_Operand_Flag,  flagmap[r], 0)
 117
 118 #define SC(i)       OP (1, RX_Operand_Immediate, 0, i)
 119 #define SR(r)       OP (1, RX_Operand_Register,  r, 0)
 120 #define SRR(r)      OP (1, RX_Operand_TwoReg,  r, 0)
 121 #define SI(r,a)     OP (1, RX_Operand_Indirect,  r, a)
 122 #define SIs(r,a,s)  OP (1, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))
 123 #define SD(t,r,s)   rx_disp (1, t, r, bwl[s], ld);
 124 #define SP(t,r)     rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
 125 #define SPm(t,r,m)  rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
 126 #define Scc(cc)     OP (1, RX_Operand_Condition,  cc, 0)
 127
 128 #define S2C(i)      OP (2, RX_Operand_Immediate, 0, i)
 129 #define S2R(r)      OP (2, RX_Operand_Register,  r, 0)
 130 #define S2I(r,a)    OP (2, RX_Operand_Indirect,  r, a)
 131 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))
 132 #define S2D(t,r,s)  rx_disp (2, t, r, bwl[s], ld);
 133 #define S2P(t,r)    rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
 134 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
 135 #define S2cc(cc)    OP (2, RX_Operand_Condition,  cc, 0)
 136
 137 #define BWL(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
 138 #define sBWL(sz)    rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
 139 #define uBW(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
 140 #define P(t, n)     rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
 141
 142 #define F(f) store_flags(rx, f)
 143
 144 #define AU ATTRIBUTE_UNUSED
 145 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
 146
 147 #define SYNTAX(x) rx->syntax = x
 148
 149 #define UNSUPPORTED() \
 150   rx->syntax = "*unknown*"
 151
 152 #define IMM(sf)   immediate (sf, 0, ld)
 153 #define IMMex(sf) immediate (sf, 1, ld)
 154
 155 static int
 156 immediate (int sfield, int ex, LocalData * ld)
 157 {
 158   unsigned long i = 0, j;
 159
 160   switch (sfield)
 161     {
 162 #define B ((unsigned long) GETBYTE())
 163     case 0:
 164 #if RX_OPCODE_BIG_ENDIAN
 165       i  = B;
 166       if (ex && (i & 0x80))
 167         i -= 0x100;
 168       i <<= 24;
 169       i |= B << 16;
 170       i |= B << 8;
 171       i |= B;
 172 #else
 173       i = B;
 174       i |= B << 8;
 175       i |= B << 16;
 176       j = B;
 177       if (ex && (j & 0x80))
 178         j -= 0x100;
 179       i |= j << 24;
 180 #endif
 181       break;
 182     case 3:
 183 #if RX_OPCODE_BIG_ENDIAN
 184       i  = B << 16;
 185       i |= B << 8;
 186       i |= B;
 187 #else
 188       i  = B;
 189       i |= B << 8;
 190       i |= B << 16;
 191 #endif
 192       if (ex && (i & 0x800000))
 193         i -= 0x1000000;
 194       break;
 195     case 2:
 196 #if RX_OPCODE_BIG_ENDIAN
 197       i |= B << 8;
 198       i |= B;
 199 #else
 200       i |= B;
 201       i |= B << 8;
 202 #endif
 203       if (ex && (i & 0x8000))
 204         i -= 0x10000;
 205       break;
 206     case 1:
 207       i |= B;
 208       if (ex && (i & 0x80))
 209         i -= 0x100;
 210       break;
 211     default:
 212       abort();
 213     }
 214   return i;
 215 }
 216
 217 static void
 218 rx_disp (int n, int type, int reg, unsigned int size, LocalData * ld)
 219 {
 220   int disp;
 221
 222   ld->rx->op[n].reg = reg;
 223   switch (type)
 224     {
 225     case 3:
 226       ld->rx->op[n].type = RX_Operand_Register;
 227       break;
 228     case 0:
 229       ld->rx->op[n].type = RX_Operand_Zero_Indirect;
 230       ld->rx->op[n].addend = 0;
 231       break;
 232     case 1:
 233       ld->rx->op[n].type = RX_Operand_Indirect;
 234       disp = GETBYTE ();
 235       ld->rx->op[n].addend = disp * GET_PSCALE (size);
 236       break;
 237     case 2:
 238       ld->rx->op[n].type = RX_Operand_Indirect;
 239       disp = GETBYTE ();
 240 #if RX_OPCODE_BIG_ENDIAN
 241       disp = disp * 256 + GETBYTE ();
 242 #else
 243       disp = disp + GETBYTE () * 256;
 244 #endif
 245       ld->rx->op[n].addend = disp * GET_PSCALE (size);
 246       break;
 247     default:
 248       abort ();
 249     }
 250 }
 251
 252 #define xO 8
 253 #define xS 4
 254 #define xZ 2
 255 #define xC 1
 256
 257 #define F_____
 258 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
 259 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
 260 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
 261 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
 262 #define F_O___ rx->flags_0 = rx->flags_s = xO;
 263 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
 264 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
 265 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
 266
 267 int
 268 rx_decode_opcode (unsigned long pc AU,
 269                   RX_Opcode_Decoded * rx,
 270                   int (* getbyte)(void *),
 271                   void * ptr)
 272 {
 273   LocalData lds, * ld = &lds;
 274   unsigned char op[20] = {0};
 275
 276   lds.rx = rx;
 277   lds.getbyte = getbyte;
 278   lds.ptr = ptr;
 279   lds.op = op;
 280
 281   memset (rx, 0, sizeof (*rx));
 282   BWL(LSIZE);
 283
 284
 285 /*----------------------------------------------------------------------*/
 286 /* MOV                                                                  */
 287
 288   GETBYTE ();
 289   switch (op[0] & 0xff)
 290   {
 291     case 0x00:
 292         {
 293           /** 0000 0000                 brk */
 294           if (trace)
 295             {
 296               printf ("\033[33m%s\033[0m  %02x\n",
 297                      "/** 0000 0000                     brk */",
 298                      op[0]);
 299             }
 300           SYNTAX("brk");
 301 #line 1029 "rx-decode.opc"
 302           ID(brk);
 303
 304         }
 305       break;
 306     case 0x01:
 307         {
 308           /** 0000 0001                 dbt */
 309           if (trace)
 310             {
 311               printf ("\033[33m%s\033[0m  %02x\n",
 312                      "/** 0000 0001                     dbt */",
 313                      op[0]);
 314             }
 315           SYNTAX("dbt");
 316 #line 1032 "rx-decode.opc"
 317           ID(dbt);
 318
 319         }
 320       break;
 321     case 0x02:
 322         {
 323           /** 0000 0010                 rts */
 324           if (trace)
 325             {
 326               printf ("\033[33m%s\033[0m  %02x\n",
 327                      "/** 0000 0010                     rts */",
 328                      op[0]);
 329             }
 330           SYNTAX("rts");
 331 #line 810 "rx-decode.opc"
 332           ID(rts);
 333
 334         /*----------------------------------------------------------------------*/
 335         /* NOP                                                          */
 336
 337         }
 338       break;
 339     case 0x03:
 340         {
 341           /** 0000 0011                 nop */
 342           if (trace)
 343             {
 344               printf ("\033[33m%s\033[0m  %02x\n",
 345                      "/** 0000 0011                     nop */",
 346                      op[0]);
 347             }
 348           SYNTAX("nop");
 349 #line 816 "rx-decode.opc"
 350           ID(nop);
 351
 352         /*----------------------------------------------------------------------*/
 353         /* STRING FUNCTIONS                                                     */
 354
 355         }
 356       break;
 357     case 0x04:
 358         {
 359           /** 0000 0100                 bra.a   %a0 */
 360           if (trace)
 361             {
 362               printf ("\033[33m%s\033[0m  %02x\n",
 363                      "/** 0000 0100                     bra.a   %a0 */",
 364                      op[0]);
 365             }
 366           SYNTAX("bra.a %a0");
 367 #line 788 "rx-decode.opc"
 368           ID(branch); DC(pc + IMMex(3));
 369
 370         }
 371       break;
 372     case 0x05:
 373         {
 374           /** 0000 0101                 bsr.a   %a0 */
 375           if (trace)
 376             {
 377               printf ("\033[33m%s\033[0m  %02x\n",
 378                      "/** 0000 0101                     bsr.a   %a0 */",
 379                      op[0]);
 380             }
 381           SYNTAX("bsr.a %a0");
 382 #line 804 "rx-decode.opc"
 383           ID(jsr); DC(pc + IMMex(3));
 384
 385         }
 386       break;
 387     case 0x06:
 388         GETBYTE ();
 389         switch (op[1] & 0xff)
 390         {
 391           case 0x00:
 392               GETBYTE ();
 393               switch (op[2] & 0x00)
 394               {
 395                 case 0x00:
 396                   op_semantics_1:
 397                     {
 398                       /** 0000 0110 mx00 00ss rsrc rdst                 sub     %2%S2, %1 */
 399 #line 546 "rx-decode.opc"
 400                       int mx AU = (op[1] >> 6) & 0x03;
 401 #line 546 "rx-decode.opc"
 402                       int ss AU = op[1] & 0x03;
 403 #line 546 "rx-decode.opc"
 404                       int rsrc AU = (op[2] >> 4) & 0x0f;
 405 #line 546 "rx-decode.opc"
 406                       int rdst AU = op[2] & 0x0f;
 407                       if (trace)
 408                         {
 409                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 410                                  "/** 0000 0110 mx00 00ss rsrc rdst                     sub     %2%S2, %1 */",
 411                                  op[0], op[1], op[2]);
 412                           printf ("  mx = 0x%x,", mx);
 413                           printf ("  ss = 0x%x,", ss);
 414                           printf ("  rsrc = 0x%x,", rsrc);
 415                           printf ("  rdst = 0x%x\n", rdst);
 416                         }
 417                       SYNTAX("sub       %2%S2, %1");
 418 #line 546 "rx-decode.opc"
 419                       ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
 420
 421                     }
 422                   break;
 423               }
 424             break;
 425           case 0x01:
 426               GETBYTE ();
 427               switch (op[2] & 0x00)
 428               {
 429                 case 0x00:
 430                   goto op_semantics_1;
 431                   break;
 432               }
 433             break;
 434           case 0x02:
 435               GETBYTE ();
 436               switch (op[2] & 0x00)
 437               {
 438                 case 0x00:
 439                   goto op_semantics_1;
 440                   break;
 441               }
 442             break;
 443           case 0x03:
 444               GETBYTE ();
 445               switch (op[2] & 0x00)
 446               {
 447                 case 0x00:
 448                   goto op_semantics_1;
 449                   break;
 450               }
 451             break;
 452           case 0x04:
 453               GETBYTE ();
 454               switch (op[2] & 0x00)
 455               {
 456                 case 0x00:
 457                   op_semantics_2:
 458                     {
 459                       /** 0000 0110 mx00 01ss rsrc rdst         cmp     %2%S2, %1 */
 460 #line 534 "rx-decode.opc"
 461                       int mx AU = (op[1] >> 6) & 0x03;
 462 #line 534 "rx-decode.opc"
 463                       int ss AU = op[1] & 0x03;
 464 #line 534 "rx-decode.opc"
 465                       int rsrc AU = (op[2] >> 4) & 0x0f;
 466 #line 534 "rx-decode.opc"
 467                       int rdst AU = op[2] & 0x0f;
 468                       if (trace)
 469                         {
 470                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 471                                  "/** 0000 0110 mx00 01ss rsrc rdst             cmp     %2%S2, %1 */",
 472                                  op[0], op[1], op[2]);
 473                           printf ("  mx = 0x%x,", mx);
 474                           printf ("  ss = 0x%x,", ss);
 475                           printf ("  rsrc = 0x%x,", rsrc);
 476                           printf ("  rdst = 0x%x\n", rdst);
 477                         }
 478                       SYNTAX("cmp       %2%S2, %1");
 479 #line 534 "rx-decode.opc"
 480                       ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
 481
 482                     /*----------------------------------------------------------------------*/
 483                     /* SUB                                                                      */
 484
 485                     }
 486                   break;
 487               }
 488             break;
 489           case 0x05:
 490               GETBYTE ();
 491               switch (op[2] & 0x00)
 492               {
 493                 case 0x00:
 494                   goto op_semantics_2;
 495                   break;
 496               }
 497             break;
 498           case 0x06:
 499               GETBYTE ();
 500               switch (op[2] & 0x00)
 501               {
 502                 case 0x00:
 503                   goto op_semantics_2;
 504                   break;
 505               }
 506             break;
 507           case 0x07:
 508               GETBYTE ();
 509               switch (op[2] & 0x00)
 510               {
 511                 case 0x00:
 512                   goto op_semantics_2;
 513                   break;
 514               }
 515             break;
 516           case 0x08:
 517               GETBYTE ();
 518               switch (op[2] & 0x00)
 519               {
 520                 case 0x00:
 521                   op_semantics_3:
 522                     {
 523                       /** 0000 0110 mx00 10ss rsrc rdst add     %1%S1, %0 */
 524 #line 510 "rx-decode.opc"
 525                       int mx AU = (op[1] >> 6) & 0x03;
 526 #line 510 "rx-decode.opc"
 527                       int ss AU = op[1] & 0x03;
 528 #line 510 "rx-decode.opc"
 529                       int rsrc AU = (op[2] >> 4) & 0x0f;
 530 #line 510 "rx-decode.opc"
 531                       int rdst AU = op[2] & 0x0f;
 532                       if (trace)
 533                         {
 534                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 535                                  "/** 0000 0110 mx00 10ss rsrc rdst     add     %1%S1, %0 */",
 536                                  op[0], op[1], op[2]);
 537                           printf ("  mx = 0x%x,", mx);
 538                           printf ("  ss = 0x%x,", ss);
 539                           printf ("  rsrc = 0x%x,", rsrc);
 540                           printf ("  rdst = 0x%x\n", rdst);
 541                         }
 542                       SYNTAX("add       %1%S1, %0");
 543 #line 510 "rx-decode.opc"
 544                       ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
 545
 546                     }
 547                   break;
 548               }
 549             break;
 550           case 0x09:
 551               GETBYTE ();
 552               switch (op[2] & 0x00)
 553               {
 554                 case 0x00:
 555                   goto op_semantics_3;
 556                   break;
 557               }
 558             break;
 559           case 0x0a:
 560               GETBYTE ();
 561               switch (op[2] & 0x00)
 562               {
 563                 case 0x00:
 564                   goto op_semantics_3;
 565                   break;
 566               }
 567             break;
 568           case 0x0b:
 569               GETBYTE ();
 570               switch (op[2] & 0x00)
 571               {
 572                 case 0x00:
 573                   goto op_semantics_3;
 574                   break;
 575               }
 576             break;
 577           case 0x0c:
 578               GETBYTE ();
 579               switch (op[2] & 0x00)
 580               {
 581                 case 0x00:
 582                   op_semantics_4:
 583                     {
 584                       /** 0000 0110 mx00 11ss rsrc rdst mul     %1%S1, %0 */
 585 #line 653 "rx-decode.opc"
 586                       int mx AU = (op[1] >> 6) & 0x03;
 587 #line 653 "rx-decode.opc"
 588                       int ss AU = op[1] & 0x03;
 589 #line 653 "rx-decode.opc"
 590                       int rsrc AU = (op[2] >> 4) & 0x0f;
 591 #line 653 "rx-decode.opc"
 592                       int rdst AU = op[2] & 0x0f;
 593                       if (trace)
 594                         {
 595                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 596                                  "/** 0000 0110 mx00 11ss rsrc rdst     mul     %1%S1, %0 */",
 597                                  op[0], op[1], op[2]);
 598                           printf ("  mx = 0x%x,", mx);
 599                           printf ("  ss = 0x%x,", ss);
 600                           printf ("  rsrc = 0x%x,", rsrc);
 601                           printf ("  rdst = 0x%x\n", rdst);
 602                         }
 603                       SYNTAX("mul       %1%S1, %0");
 604 #line 653 "rx-decode.opc"
 605                       ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
 606
 607                     }
 608                   break;
 609               }
 610             break;
 611           case 0x0d:
 612               GETBYTE ();
 613               switch (op[2] & 0x00)
 614               {
 615                 case 0x00:
 616                   goto op_semantics_4;
 617                   break;
 618               }
 619             break;
 620           case 0x0e:
 621               GETBYTE ();
 622               switch (op[2] & 0x00)
 623               {
 624                 case 0x00:
 625                   goto op_semantics_4;
 626                   break;
 627               }
 628             break;
 629           case 0x0f:
 630               GETBYTE ();
 631               switch (op[2] & 0x00)
 632               {
 633                 case 0x00:
 634                   goto op_semantics_4;
 635                   break;
 636               }
 637             break;
 638           case 0x10:
 639               GETBYTE ();
 640               switch (op[2] & 0x00)
 641               {
 642                 case 0x00:
 643                   op_semantics_5:
 644                     {
 645                       /** 0000 0110 mx01 00ss rsrc rdst and     %1%S1, %0 */
 646 #line 423 "rx-decode.opc"
 647                       int mx AU = (op[1] >> 6) & 0x03;
 648 #line 423 "rx-decode.opc"
 649                       int ss AU = op[1] & 0x03;
 650 #line 423 "rx-decode.opc"
 651                       int rsrc AU = (op[2] >> 4) & 0x0f;
 652 #line 423 "rx-decode.opc"
 653                       int rdst AU = op[2] & 0x0f;
 654                       if (trace)
 655                         {
 656                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 657                                  "/** 0000 0110 mx01 00ss rsrc rdst     and     %1%S1, %0 */",
 658                                  op[0], op[1], op[2]);
 659                           printf ("  mx = 0x%x,", mx);
 660                           printf ("  ss = 0x%x,", ss);
 661                           printf ("  rsrc = 0x%x,", rsrc);
 662                           printf ("  rdst = 0x%x\n", rdst);
 663                         }
 664                       SYNTAX("and       %1%S1, %0");
 665 #line 423 "rx-decode.opc"
 666                       ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
 667
 668                     }
 669                   break;
 670               }
 671             break;
 672           case 0x11:
 673               GETBYTE ();
 674               switch (op[2] & 0x00)
 675               {
 676                 case 0x00:
 677                   goto op_semantics_5;
 678                   break;
 679               }
 680             break;
 681           case 0x12:
 682               GETBYTE ();
 683               switch (op[2] & 0x00)
 684               {
 685                 case 0x00:
 686                   goto op_semantics_5;
 687                   break;
 688               }
 689             break;
 690           case 0x13:
 691               GETBYTE ();
 692               switch (op[2] & 0x00)
 693               {
 694                 case 0x00:
 695                   goto op_semantics_5;
 696                   break;
 697               }
 698             break;
 699           case 0x14:
 700               GETBYTE ();
 701               switch (op[2] & 0x00)
 702               {
 703                 case 0x00:
 704                   op_semantics_6:
 705                     {
 706                       /** 0000 0110 mx01 01ss rsrc rdst                 or      %1%S1, %0 */
 707 #line 441 "rx-decode.opc"
 708                       int mx AU = (op[1] >> 6) & 0x03;
 709 #line 441 "rx-decode.opc"
 710                       int ss AU = op[1] & 0x03;
 711 #line 441 "rx-decode.opc"
 712                       int rsrc AU = (op[2] >> 4) & 0x0f;
 713 #line 441 "rx-decode.opc"
 714                       int rdst AU = op[2] & 0x0f;
 715                       if (trace)
 716                         {
 717                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 718                                  "/** 0000 0110 mx01 01ss rsrc rdst                     or      %1%S1, %0 */",
 719                                  op[0], op[1], op[2]);
 720                           printf ("  mx = 0x%x,", mx);
 721                           printf ("  ss = 0x%x,", ss);
 722                           printf ("  rsrc = 0x%x,", rsrc);
 723                           printf ("  rdst = 0x%x\n", rdst);
 724                         }
 725                       SYNTAX("or        %1%S1, %0");
 726 #line 441 "rx-decode.opc"
 727                       ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
 728
 729                     }
 730                   break;
 731               }
 732             break;
 733           case 0x15:
 734               GETBYTE ();
 735               switch (op[2] & 0x00)
 736               {
 737                 case 0x00:
 738                   goto op_semantics_6;
 739                   break;
 740               }
 741             break;
 742           case 0x16:
 743               GETBYTE ();
 744               switch (op[2] & 0x00)
 745               {
 746                 case 0x00:
 747                   goto op_semantics_6;
 748                   break;
 749               }
 750             break;
 751           case 0x17:
 752               GETBYTE ();
 753               switch (op[2] & 0x00)
 754               {
 755                 case 0x00:
 756                   goto op_semantics_6;
 757                   break;
 758               }
 759             break;
 760           case 0x20:
 761               GETBYTE ();
 762               switch (op[2] & 0xff)
 763               {
 764                 case 0x00:
 765                     GETBYTE ();
 766                     switch (op[3] & 0x00)
 767                     {
 768                       case 0x00:
 769                         op_semantics_7:
 770                           {
 771                             /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb     %1%S1, %0 */
 772 #line 559 "rx-decode.opc"
 773                             int mx AU = (op[1] >> 6) & 0x03;
 774 #line 559 "rx-decode.opc"
 775                             int sp AU = op[1] & 0x03;
 776 #line 559 "rx-decode.opc"
 777                             int rsrc AU = (op[3] >> 4) & 0x0f;
 778 #line 559 "rx-decode.opc"
 779                             int rdst AU = op[3] & 0x0f;
 780                             if (trace)
 781                               {
 782                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 783                                        "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst     sbb     %1%S1, %0 */",
 784                                        op[0], op[1], op[2], op[3]);
 785                                 printf ("  mx = 0x%x,", mx);
 786                                 printf ("  sp = 0x%x,", sp);
 787                                 printf ("  rsrc = 0x%x,", rsrc);
 788                                 printf ("  rdst = 0x%x\n", rdst);
 789                               }
 790                             SYNTAX("sbb %1%S1, %0");
 791 #line 559 "rx-decode.opc"
 792                             ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
 793
 794                           /*----------------------------------------------------------------------*/
 795                           /* ABS                                                                        */
 796
 797                           }
 798                         break;
 799                     }
 800                   break;
 801                 case 0x04:
 802                     GETBYTE ();
 803                     switch (op[3] & 0x00)
 804                     {
 805                       case 0x00:
 806                         op_semantics_8:
 807                           {
 808                             /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max     %1%S1, %0 */
 809 #line 598 "rx-decode.opc"
 810                             int mx AU = (op[1] >> 6) & 0x03;
 811 #line 598 "rx-decode.opc"
 812                             int ss AU = op[1] & 0x03;
 813 #line 598 "rx-decode.opc"
 814                             int rsrc AU = (op[3] >> 4) & 0x0f;
 815 #line 598 "rx-decode.opc"
 816                             int rdst AU = op[3] & 0x0f;
 817                             if (trace)
 818                               {
 819                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 820                                        "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst     max     %1%S1, %0 */",
 821                                        op[0], op[1], op[2], op[3]);
 822                                 printf ("  mx = 0x%x,", mx);
 823                                 printf ("  ss = 0x%x,", ss);
 824                                 printf ("  rsrc = 0x%x,", rsrc);
 825                                 printf ("  rdst = 0x%x\n", rdst);
 826                               }
 827                             SYNTAX("max %1%S1, %0");
 828 #line 598 "rx-decode.opc"
 829                             ID(max); SPm(ss, rsrc, mx); DR(rdst);
 830
 831                           /*----------------------------------------------------------------------*/
 832                           /* MIN                                                                        */
 833
 834                           }
 835                         break;
 836                     }
 837                   break;
 838                 case 0x05:
 839                     GETBYTE ();
 840                     switch (op[3] & 0x00)
 841                     {
 842                       case 0x00:
 843                         op_semantics_9:
 844                           {
 845                             /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min     %1%S1, %0 */
 846 #line 610 "rx-decode.opc"
 847                             int mx AU = (op[1] >> 6) & 0x03;
 848 #line 610 "rx-decode.opc"
 849                             int ss AU = op[1] & 0x03;
 850 #line 610 "rx-decode.opc"
 851                             int rsrc AU = (op[3] >> 4) & 0x0f;
 852 #line 610 "rx-decode.opc"
 853                             int rdst AU = op[3] & 0x0f;
 854                             if (trace)
 855                               {
 856                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 857                                        "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst     min     %1%S1, %0 */",
 858                                        op[0], op[1], op[2], op[3]);
 859                                 printf ("  mx = 0x%x,", mx);
 860                                 printf ("  ss = 0x%x,", ss);
 861                                 printf ("  rsrc = 0x%x,", rsrc);
 862                                 printf ("  rdst = 0x%x\n", rdst);
 863                               }
 864                             SYNTAX("min %1%S1, %0");
 865 #line 610 "rx-decode.opc"
 866                             ID(min); SPm(ss, rsrc, mx); DR(rdst);
 867
 868                           /*----------------------------------------------------------------------*/
 869                           /* MUL                                                                        */
 870
 871                           }
 872                         break;
 873                     }
 874                   break;
 875                 case 0x06:
 876                     GETBYTE ();
 877                     switch (op[3] & 0x00)
 878                     {
 879                       case 0x00:
 880                         op_semantics_10:
 881                           {
 882                             /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul    %1%S1, %0 */
 883 #line 668 "rx-decode.opc"
 884                             int mx AU = (op[1] >> 6) & 0x03;
 885 #line 668 "rx-decode.opc"
 886                             int ss AU = op[1] & 0x03;
 887 #line 668 "rx-decode.opc"
 888                             int rsrc AU = (op[3] >> 4) & 0x0f;
 889 #line 668 "rx-decode.opc"
 890                             int rdst AU = op[3] & 0x0f;
 891                             if (trace)
 892                               {
 893                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 894                                        "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst     emul    %1%S1, %0 */",
 895                                        op[0], op[1], op[2], op[3]);
 896                                 printf ("  mx = 0x%x,", mx);
 897                                 printf ("  ss = 0x%x,", ss);
 898                                 printf ("  rsrc = 0x%x,", rsrc);
 899                                 printf ("  rdst = 0x%x\n", rdst);
 900                               }
 901                             SYNTAX("emul        %1%S1, %0");
 902 #line 668 "rx-decode.opc"
 903                             ID(emul); SPm(ss, rsrc, mx); DR(rdst);
 904
 905                           /*----------------------------------------------------------------------*/
 906                           /* EMULU                                                                      */
 907
 908                           }
 909                         break;
 910                     }
 911                   break;
 912                 case 0x07:
 913                     GETBYTE ();
 914                     switch (op[3] & 0x00)
 915                     {
 916                       case 0x00:
 917                         op_semantics_11:
 918                           {
 919                             /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu   %1%S1, %0 */
 920 #line 680 "rx-decode.opc"
 921                             int mx AU = (op[1] >> 6) & 0x03;
 922 #line 680 "rx-decode.opc"
 923                             int ss AU = op[1] & 0x03;
 924 #line 680 "rx-decode.opc"
 925                             int rsrc AU = (op[3] >> 4) & 0x0f;
 926 #line 680 "rx-decode.opc"
 927                             int rdst AU = op[3] & 0x0f;
 928                             if (trace)
 929                               {
 930                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 931                                        "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst     emulu   %1%S1, %0 */",
 932                                        op[0], op[1], op[2], op[3]);
 933                                 printf ("  mx = 0x%x,", mx);
 934                                 printf ("  ss = 0x%x,", ss);
 935                                 printf ("  rsrc = 0x%x,", rsrc);
 936                                 printf ("  rdst = 0x%x\n", rdst);
 937                               }
 938                             SYNTAX("emulu       %1%S1, %0");
 939 #line 680 "rx-decode.opc"
 940                             ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
 941
 942                           /*----------------------------------------------------------------------*/
 943                           /* DIV                                                                        */
 944
 945                           }
 946                         break;
 947                     }
 948                   break;
 949                 case 0x08:
 950                     GETBYTE ();
 951                     switch (op[3] & 0x00)
 952                     {
 953                       case 0x00:
 954                         op_semantics_12:
 955                           {
 956                             /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div     %1%S1, %0 */
 957 #line 692 "rx-decode.opc"
 958                             int mx AU = (op[1] >> 6) & 0x03;
 959 #line 692 "rx-decode.opc"
 960                             int ss AU = op[1] & 0x03;
 961 #line 692 "rx-decode.opc"
 962                             int rsrc AU = (op[3] >> 4) & 0x0f;
 963 #line 692 "rx-decode.opc"
 964                             int rdst AU = op[3] & 0x0f;
 965                             if (trace)
 966                               {
 967                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 968                                        "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst     div     %1%S1, %0 */",
 969                                        op[0], op[1], op[2], op[3]);
 970                                 printf ("  mx = 0x%x,", mx);
 971                                 printf ("  ss = 0x%x,", ss);
 972                                 printf ("  rsrc = 0x%x,", rsrc);
 973                                 printf ("  rdst = 0x%x\n", rdst);
 974                               }
 975                             SYNTAX("div %1%S1, %0");
 976 #line 692 "rx-decode.opc"
 977                             ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
 978
 979                           /*----------------------------------------------------------------------*/
 980                           /* DIVU                                                                       */
 981
 982                           }
 983                         break;
 984                     }
 985                   break;
 986                 case 0x09:
 987                     GETBYTE ();
 988                     switch (op[3] & 0x00)
 989                     {
 990                       case 0x00:
 991                         op_semantics_13:
 992                           {
 993                             /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu    %1%S1, %0 */
 994 #line 704 "rx-decode.opc"
 995                             int mx AU = (op[1] >> 6) & 0x03;
 996 #line 704 "rx-decode.opc"
 997                             int ss AU = op[1] & 0x03;
 998 #line 704 "rx-decode.opc"
 999                             int rsrc AU = (op[3] >> 4) & 0x0f;
1000 #line 704 "rx-decode.opc"
1001                             int rdst AU = op[3] & 0x0f;
1002                             if (trace)
1003                               {
1004                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1005                                        "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst     divu    %1%S1, %0 */",
1006                                        op[0], op[1], op[2], op[3]);
1007                                 printf ("  mx = 0x%x,", mx);
1008                                 printf ("  ss = 0x%x,", ss);
1009                                 printf ("  rsrc = 0x%x,", rsrc);
1010                                 printf ("  rdst = 0x%x\n", rdst);
1011                               }
1012                             SYNTAX("divu        %1%S1, %0");
1013 #line 704 "rx-decode.opc"
1014                             ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1015
1016                           /*----------------------------------------------------------------------*/
1017                           /* SHIFT                                                              */
1018
1019                           }
1020                         break;
1021                     }
1022                   break;
1023                 case 0x0c:
1024                     GETBYTE ();
1025                     switch (op[3] & 0x00)
1026                     {
1027                       case 0x00:
1028                         op_semantics_14:
1029                           {
1030                             /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst     %1%S1, %2 */
1031 #line 477 "rx-decode.opc"
1032                             int mx AU = (op[1] >> 6) & 0x03;
1033 #line 477 "rx-decode.opc"
1034                             int ss AU = op[1] & 0x03;
1035 #line 477 "rx-decode.opc"
1036                             int rsrc AU = (op[3] >> 4) & 0x0f;
1037 #line 477 "rx-decode.opc"
1038                             int rdst AU = op[3] & 0x0f;
1039                             if (trace)
1040                               {
1041                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1042                                        "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst     tst     %1%S1, %2 */",
1043                                        op[0], op[1], op[2], op[3]);
1044                                 printf ("  mx = 0x%x,", mx);
1045                                 printf ("  ss = 0x%x,", ss);
1046                                 printf ("  rsrc = 0x%x,", rsrc);
1047                                 printf ("  rdst = 0x%x\n", rdst);
1048                               }
1049                             SYNTAX("tst %1%S1, %2");
1050 #line 477 "rx-decode.opc"
1051                             ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1052
1053                           /*----------------------------------------------------------------------*/
1054                           /* NEG                                                                        */
1055
1056                           }
1057                         break;
1058                     }
1059                   break;
1060                 case 0x0d:
1061                     GETBYTE ();
1062                     switch (op[3] & 0x00)
1063                     {
1064                       case 0x00:
1065                         op_semantics_15:
1066                           {
1067                             /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor     %1%S1, %0 */
1068 #line 456 "rx-decode.opc"
1069                             int mx AU = (op[1] >> 6) & 0x03;
1070 #line 456 "rx-decode.opc"
1071                             int ss AU = op[1] & 0x03;
1072 #line 456 "rx-decode.opc"
1073                             int rsrc AU = (op[3] >> 4) & 0x0f;
1074 #line 456 "rx-decode.opc"
1075                             int rdst AU = op[3] & 0x0f;
1076                             if (trace)
1077                               {
1078                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1079                                        "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst     xor     %1%S1, %0 */",
1080                                        op[0], op[1], op[2], op[3]);
1081                                 printf ("  mx = 0x%x,", mx);
1082                                 printf ("  ss = 0x%x,", ss);
1083                                 printf ("  rsrc = 0x%x,", rsrc);
1084                                 printf ("  rdst = 0x%x\n", rdst);
1085                               }
1086                             SYNTAX("xor %1%S1, %0");
1087 #line 456 "rx-decode.opc"
1088                             ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1089
1090                           /*----------------------------------------------------------------------*/
1091                           /* NOT                                                                        */
1092
1093                           }
1094                         break;
1095                     }
1096                   break;
1097                 case 0x10:
1098                     GETBYTE ();
1099                     switch (op[3] & 0x00)
1100                     {
1101                       case 0x00:
1102                         op_semantics_16:
1103                           {
1104                             /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg    %1%S1, %0 */
1105 #line 390 "rx-decode.opc"
1106                             int mx AU = (op[1] >> 6) & 0x03;
1107 #line 390 "rx-decode.opc"
1108                             int ss AU = op[1] & 0x03;
1109 #line 390 "rx-decode.opc"
1110                             int rsrc AU = (op[3] >> 4) & 0x0f;
1111 #line 390 "rx-decode.opc"
1112                             int rdst AU = op[3] & 0x0f;
1113                             if (trace)
1114                               {
1115                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1116                                        "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst     xchg    %1%S1, %0 */",
1117                                        op[0], op[1], op[2], op[3]);
1118                                 printf ("  mx = 0x%x,", mx);
1119                                 printf ("  ss = 0x%x,", ss);
1120                                 printf ("  rsrc = 0x%x,", rsrc);
1121                                 printf ("  rdst = 0x%x\n", rdst);
1122                               }
1123                             SYNTAX("xchg        %1%S1, %0");
1124 #line 390 "rx-decode.opc"
1125                             ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1126
1127                           /*----------------------------------------------------------------------*/
1128                           /* STZ/STNZ                                                           */
1129
1130                           }
1131                         break;
1132                     }
1133                   break;
1134                 case 0x11:
1135                     GETBYTE ();
1136                     switch (op[3] & 0x00)
1137                     {
1138                       case 0x00:
1139                         op_semantics_17:
1140                           {
1141                             /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof    %1%S1, %0 */
1142 #line 933 "rx-decode.opc"
1143                             int mx AU = (op[1] >> 6) & 0x03;
1144 #line 933 "rx-decode.opc"
1145                             int sd AU = op[1] & 0x03;
1146 #line 933 "rx-decode.opc"
1147                             int rsrc AU = (op[3] >> 4) & 0x0f;
1148 #line 933 "rx-decode.opc"
1149                             int rdst AU = op[3] & 0x0f;
1150                             if (trace)
1151                               {
1152                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1153                                        "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst     itof    %1%S1, %0 */",
1154                                        op[0], op[1], op[2], op[3]);
1155                                 printf ("  mx = 0x%x,", mx);
1156                                 printf ("  sd = 0x%x,", sd);
1157                                 printf ("  rsrc = 0x%x,", rsrc);
1158                                 printf ("  rdst = 0x%x\n", rdst);
1159                               }
1160                             SYNTAX("itof        %1%S1, %0");
1161 #line 933 "rx-decode.opc"
1162                             ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1163
1164                           /*----------------------------------------------------------------------*/
1165                           /* BIT OPS                                                            */
1166
1167                           }
1168                         break;
1169                     }
1170                   break;
1171                 case 0x15:
1172                     GETBYTE ();
1173                     switch (op[3] & 0x00)
1174                     {
1175                       case 0x00:
1176                         op_semantics_18:
1177                           {
1178                             /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof    %1%S1, %0 */
1179 #line 1119 "rx-decode.opc"
1180                             int mx AU = (op[1] >> 6) & 0x03;
1181 #line 1119 "rx-decode.opc"
1182                             int sd AU = op[1] & 0x03;
1183 #line 1119 "rx-decode.opc"
1184                             int rsrc AU = (op[3] >> 4) & 0x0f;
1185 #line 1119 "rx-decode.opc"
1186                             int rdst AU = op[3] & 0x0f;
1187                             if (trace)
1188                               {
1189                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1190                                        "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst     utof    %1%S1, %0 */",
1191                                        op[0], op[1], op[2], op[3]);
1192                                 printf ("  mx = 0x%x,", mx);
1193                                 printf ("  sd = 0x%x,", sd);
1194                                 printf ("  rsrc = 0x%x,", rsrc);
1195                                 printf ("  rdst = 0x%x\n", rdst);
1196                               }
1197                             SYNTAX("utof        %1%S1, %0");
1198 #line 1119 "rx-decode.opc"
1199                             ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1200
1201                           }
1202                         break;
1203                     }
1204                   break;
1205                 default: UNSUPPORTED(); break;
1206               }
1207             break;
1208           case 0x21:
1209               GETBYTE ();
1210               switch (op[2] & 0xff)
1211               {
1212                 case 0x00:
1213                     GETBYTE ();
1214                     switch (op[3] & 0x00)
1215                     {
1216                       case 0x00:
1217                         goto op_semantics_7;
1218                         break;
1219                     }
1220                   break;
1221                 case 0x04:
1222                     GETBYTE ();
1223                     switch (op[3] & 0x00)
1224                     {
1225                       case 0x00:
1226                         goto op_semantics_8;
1227                         break;
1228                     }
1229                   break;
1230                 case 0x05:
1231                     GETBYTE ();
1232                     switch (op[3] & 0x00)
1233                     {
1234                       case 0x00:
1235                         goto op_semantics_9;
1236                         break;
1237                     }
1238                   break;
1239                 case 0x06:
1240                     GETBYTE ();
1241                     switch (op[3] & 0x00)
1242                     {
1243                       case 0x00:
1244                         goto op_semantics_10;
1245                         break;
1246                     }
1247                   break;
1248                 case 0x07:
1249                     GETBYTE ();
1250                     switch (op[3] & 0x00)
1251                     {
1252                       case 0x00:
1253                         goto op_semantics_11;
1254                         break;
1255                     }
1256                   break;
1257                 case 0x08:
1258                     GETBYTE ();
1259                     switch (op[3] & 0x00)
1260                     {
1261                       case 0x00:
1262                         goto op_semantics_12;
1263                         break;
1264                     }
1265                   break;
1266                 case 0x09:
1267                     GETBYTE ();
1268                     switch (op[3] & 0x00)
1269                     {
1270                       case 0x00:
1271                         goto op_semantics_13;
1272                         break;
1273                     }
1274                   break;
1275                 case 0x0c:
1276                     GETBYTE ();
1277                     switch (op[3] & 0x00)
1278                     {
1279                       case 0x00:
1280                         goto op_semantics_14;
1281                         break;
1282                     }
1283                   break;
1284                 case 0x0d:
1285                     GETBYTE ();
1286                     switch (op[3] & 0x00)
1287                     {
1288                       case 0x00:
1289                         goto op_semantics_15;
1290                         break;
1291                     }
1292                   break;
1293                 case 0x10:
1294                     GETBYTE ();
1295                     switch (op[3] & 0x00)
1296                     {
1297                       case 0x00:
1298                         goto op_semantics_16;
1299                         break;
1300                     }
1301                   break;
1302                 case 0x11:
1303                     GETBYTE ();
1304                     switch (op[3] & 0x00)
1305                     {
1306                       case 0x00:
1307                         goto op_semantics_17;
1308                         break;
1309                     }
1310                   break;
1311                 case 0x15:
1312                     GETBYTE ();
1313                     switch (op[3] & 0x00)
1314                     {
1315                       case 0x00:
1316                         goto op_semantics_18;
1317                         break;
1318                     }
1319                   break;
1320                 default: UNSUPPORTED(); break;
1321               }
1322             break;
1323           case 0x22:
1324               GETBYTE ();
1325               switch (op[2] & 0xff)
1326               {
1327                 case 0x00:
1328                     GETBYTE ();
1329                     switch (op[3] & 0x00)
1330                     {
1331                       case 0x00:
1332                         goto op_semantics_7;
1333                         break;
1334                     }
1335                   break;
1336                 case 0x04:
1337                     GETBYTE ();
1338                     switch (op[3] & 0x00)
1339                     {
1340                       case 0x00:
1341                         goto op_semantics_8;
1342                         break;
1343                     }
1344                   break;
1345                 case 0x05:
1346                     GETBYTE ();
1347                     switch (op[3] & 0x00)
1348                     {
1349                       case 0x00:
1350                         goto op_semantics_9;
1351                         break;
1352                     }
1353                   break;
1354                 case 0x06:
1355                     GETBYTE ();
1356                     switch (op[3] & 0x00)
1357                     {
1358                       case 0x00:
1359                         goto op_semantics_10;
1360                         break;
1361                     }
1362                   break;
1363                 case 0x07:
1364                     GETBYTE ();
1365                     switch (op[3] & 0x00)
1366                     {
1367                       case 0x00:
1368                         goto op_semantics_11;
1369                         break;
1370                     }
1371                   break;
1372                 case 0x08:
1373                     GETBYTE ();
1374                     switch (op[3] & 0x00)
1375                     {
1376                       case 0x00:
1377                         goto op_semantics_12;
1378                         break;
1379                     }
1380                   break;
1381                 case 0x09:
1382                     GETBYTE ();
1383                     switch (op[3] & 0x00)
1384                     {
1385                       case 0x00:
1386                         goto op_semantics_13;
1387                         break;
1388                     }
1389                   break;
1390                 case 0x0c:
1391                     GETBYTE ();
1392                     switch (op[3] & 0x00)
1393                     {
1394                       case 0x00:
1395                         goto op_semantics_14;
1396                         break;
1397                     }
1398                   break;
1399                 case 0x0d:
1400                     GETBYTE ();
1401                     switch (op[3] & 0x00)
1402                     {
1403                       case 0x00:
1404                         goto op_semantics_15;
1405                         break;
1406                     }
1407                   break;
1408                 case 0x10:
1409                     GETBYTE ();
1410                     switch (op[3] & 0x00)
1411                     {
1412                       case 0x00:
1413                         goto op_semantics_16;
1414                         break;
1415                     }
1416                   break;
1417                 case 0x11:
1418                     GETBYTE ();
1419                     switch (op[3] & 0x00)
1420                     {
1421                       case 0x00:
1422                         goto op_semantics_17;
1423                         break;
1424                     }
1425                   break;
1426                 case 0x15:
1427                     GETBYTE ();
1428                     switch (op[3] & 0x00)
1429                     {
1430                       case 0x00:
1431                         goto op_semantics_18;
1432                         break;
1433                     }
1434                   break;
1435                 default: UNSUPPORTED(); break;
1436               }
1437             break;
1438           case 0x23:
1439               GETBYTE ();
1440               switch (op[2] & 0xff)
1441               {
1442                 case 0x00:
1443                     GETBYTE ();
1444                     switch (op[3] & 0x00)
1445                     {
1446                       case 0x00:
1447                         goto op_semantics_7;
1448                         break;
1449                     }
1450                   break;
1451                 case 0x04:
1452                     GETBYTE ();
1453                     switch (op[3] & 0x00)
1454                     {
1455                       case 0x00:
1456                         goto op_semantics_8;
1457                         break;
1458                     }
1459                   break;
1460                 case 0x05:
1461                     GETBYTE ();
1462                     switch (op[3] & 0x00)
1463                     {
1464                       case 0x00:
1465                         goto op_semantics_9;
1466                         break;
1467                     }
1468                   break;
1469                 case 0x06:
1470                     GETBYTE ();
1471                     switch (op[3] & 0x00)
1472                     {
1473                       case 0x00:
1474                         goto op_semantics_10;
1475                         break;
1476                     }
1477                   break;
1478                 case 0x07:
1479                     GETBYTE ();
1480                     switch (op[3] & 0x00)
1481                     {
1482                       case 0x00:
1483                         goto op_semantics_11;
1484                         break;
1485                     }
1486                   break;
1487                 case 0x08:
1488                     GETBYTE ();
1489                     switch (op[3] & 0x00)
1490                     {
1491                       case 0x00:
1492                         goto op_semantics_12;
1493                         break;
1494                     }
1495                   break;
1496                 case 0x09:
1497                     GETBYTE ();
1498                     switch (op[3] & 0x00)
1499                     {
1500                       case 0x00:
1501                         goto op_semantics_13;
1502                         break;
1503                     }
1504                   break;
1505                 case 0x0c:
1506                     GETBYTE ();
1507                     switch (op[3] & 0x00)
1508                     {
1509                       case 0x00:
1510                         goto op_semantics_14;
1511                         break;
1512                     }
1513                   break;
1514                 case 0x0d:
1515                     GETBYTE ();
1516                     switch (op[3] & 0x00)
1517                     {
1518                       case 0x00:
1519                         goto op_semantics_15;
1520                         break;
1521                     }
1522                   break;
1523                 case 0x10:
1524                     GETBYTE ();
1525                     switch (op[3] & 0x00)
1526                     {
1527                       case 0x00:
1528                         goto op_semantics_16;
1529                         break;
1530                     }
1531                   break;
1532                 case 0x11:
1533                     GETBYTE ();
1534                     switch (op[3] & 0x00)
1535                     {
1536                       case 0x00:
1537                         goto op_semantics_17;
1538                         break;
1539                     }
1540                   break;
1541                 case 0x15:
1542                     GETBYTE ();
1543                     switch (op[3] & 0x00)
1544                     {
1545                       case 0x00:
1546                         goto op_semantics_18;
1547                         break;
1548                     }
1549                   break;
1550                 default: UNSUPPORTED(); break;
1551               }
1552             break;
1553           case 0x40:
1554               GETBYTE ();
1555               switch (op[2] & 0x00)
1556               {
1557                 case 0x00:
1558                   goto op_semantics_1;
1559                   break;
1560               }
1561             break;
1562           case 0x41:
1563               GETBYTE ();
1564               switch (op[2] & 0x00)
1565               {
1566                 case 0x00:
1567                   goto op_semantics_1;
1568                   break;
1569               }
1570             break;
1571           case 0x42:
1572               GETBYTE ();
1573               switch (op[2] & 0x00)
1574               {
1575                 case 0x00:
1576                   goto op_semantics_1;
1577                   break;
1578               }
1579             break;
1580           case 0x43:
1581               GETBYTE ();
1582               switch (op[2] & 0x00)
1583               {
1584                 case 0x00:
1585                   goto op_semantics_1;
1586                   break;
1587               }
1588             break;
1589           case 0x44:
1590               GETBYTE ();
1591               switch (op[2] & 0x00)
1592               {
1593                 case 0x00:
1594                   goto op_semantics_2;
1595                   break;
1596               }
1597             break;
1598           case 0x45:
1599               GETBYTE ();
1600               switch (op[2] & 0x00)
1601               {
1602                 case 0x00:
1603                   goto op_semantics_2;
1604                   break;
1605               }
1606             break;
1607           case 0x46:
1608               GETBYTE ();
1609               switch (op[2] & 0x00)
1610               {
1611                 case 0x00:
1612                   goto op_semantics_2;
1613                   break;
1614               }
1615             break;
1616           case 0x47:
1617               GETBYTE ();
1618               switch (op[2] & 0x00)
1619               {
1620                 case 0x00:
1621                   goto op_semantics_2;
1622                   break;
1623               }
1624             break;
1625           case 0x48:
1626               GETBYTE ();
1627               switch (op[2] & 0x00)
1628               {
1629                 case 0x00:
1630                   goto op_semantics_3;
1631                   break;
1632               }
1633             break;
1634           case 0x49:
1635               GETBYTE ();
1636               switch (op[2] & 0x00)
1637               {
1638                 case 0x00:
1639                   goto op_semantics_3;
1640                   break;
1641               }
1642             break;
1643           case 0x4a:
1644               GETBYTE ();
1645               switch (op[2] & 0x00)
1646               {
1647                 case 0x00:
1648                   goto op_semantics_3;
1649                   break;
1650               }
1651             break;
1652           case 0x4b:
1653               GETBYTE ();
1654               switch (op[2] & 0x00)
1655               {
1656                 case 0x00:
1657                   goto op_semantics_3;
1658                   break;
1659               }
1660             break;
1661           case 0x4c:
1662               GETBYTE ();
1663               switch (op[2] & 0x00)
1664               {
1665                 case 0x00:
1666                   goto op_semantics_4;
1667                   break;
1668               }
1669             break;
1670           case 0x4d:
1671               GETBYTE ();
1672               switch (op[2] & 0x00)
1673               {
1674                 case 0x00:
1675                   goto op_semantics_4;
1676                   break;
1677               }
1678             break;
1679           case 0x4e:
1680               GETBYTE ();
1681               switch (op[2] & 0x00)
1682               {
1683                 case 0x00:
1684                   goto op_semantics_4;
1685                   break;
1686               }
1687             break;
1688           case 0x4f:
1689               GETBYTE ();
1690               switch (op[2] & 0x00)
1691               {
1692                 case 0x00:
1693                   goto op_semantics_4;
1694                   break;
1695               }
1696             break;
1697           case 0x50:
1698               GETBYTE ();
1699               switch (op[2] & 0x00)
1700               {
1701                 case 0x00:
1702                   goto op_semantics_5;
1703                   break;
1704               }
1705             break;
1706           case 0x51:
1707               GETBYTE ();
1708               switch (op[2] & 0x00)
1709               {
1710                 case 0x00:
1711                   goto op_semantics_5;
1712                   break;
1713               }
1714             break;
1715           case 0x52:
1716               GETBYTE ();
1717               switch (op[2] & 0x00)
1718               {
1719                 case 0x00:
1720                   goto op_semantics_5;
1721                   break;
1722               }
1723             break;
1724           case 0x53:
1725               GETBYTE ();
1726               switch (op[2] & 0x00)
1727               {
1728                 case 0x00:
1729                   goto op_semantics_5;
1730                   break;
1731               }
1732             break;
1733           case 0x54:
1734               GETBYTE ();
1735               switch (op[2] & 0x00)
1736               {
1737                 case 0x00:
1738                   goto op_semantics_6;
1739                   break;
1740               }
1741             break;
1742           case 0x55:
1743               GETBYTE ();
1744               switch (op[2] & 0x00)
1745               {
1746                 case 0x00:
1747                   goto op_semantics_6;
1748                   break;
1749               }
1750             break;
1751           case 0x56:
1752               GETBYTE ();
1753               switch (op[2] & 0x00)
1754               {
1755                 case 0x00:
1756                   goto op_semantics_6;
1757                   break;
1758               }
1759             break;
1760           case 0x57:
1761               GETBYTE ();
1762               switch (op[2] & 0x00)
1763               {
1764                 case 0x00:
1765                   goto op_semantics_6;
1766                   break;
1767               }
1768             break;
1769           case 0x60:
1770               GETBYTE ();
1771               switch (op[2] & 0xff)
1772               {
1773                 case 0x00:
1774                     GETBYTE ();
1775                     switch (op[3] & 0x00)
1776                     {
1777                       case 0x00:
1778                         goto op_semantics_7;
1779                         break;
1780                     }
1781                   break;
1782                 case 0x04:
1783                     GETBYTE ();
1784                     switch (op[3] & 0x00)
1785                     {
1786                       case 0x00:
1787                         goto op_semantics_8;
1788                         break;
1789                     }
1790                   break;
1791                 case 0x05:
1792                     GETBYTE ();
1793                     switch (op[3] & 0x00)
1794                     {
1795                       case 0x00:
1796                         goto op_semantics_9;
1797                         break;
1798                     }
1799                   break;
1800                 case 0x06:
1801                     GETBYTE ();
1802                     switch (op[3] & 0x00)
1803                     {
1804                       case 0x00:
1805                         goto op_semantics_10;
1806                         break;
1807                     }
1808                   break;
1809                 case 0x07:
1810                     GETBYTE ();
1811                     switch (op[3] & 0x00)
1812                     {
1813                       case 0x00:
1814                         goto op_semantics_11;
1815                         break;
1816                     }
1817                   break;
1818                 case 0x08:
1819                     GETBYTE ();
1820                     switch (op[3] & 0x00)
1821                     {
1822                       case 0x00:
1823                         goto op_semantics_12;
1824                         break;
1825                     }
1826                   break;
1827                 case 0x09:
1828                     GETBYTE ();
1829                     switch (op[3] & 0x00)
1830                     {
1831                       case 0x00:
1832                         goto op_semantics_13;
1833                         break;
1834                     }
1835                   break;
1836                 case 0x0c:
1837                     GETBYTE ();
1838                     switch (op[3] & 0x00)
1839                     {
1840                       case 0x00:
1841                         goto op_semantics_14;
1842                         break;
1843                     }
1844                   break;
1845                 case 0x0d:
1846                     GETBYTE ();
1847                     switch (op[3] & 0x00)
1848                     {
1849                       case 0x00:
1850                         goto op_semantics_15;
1851                         break;
1852                     }
1853                   break;
1854                 case 0x10:
1855                     GETBYTE ();
1856                     switch (op[3] & 0x00)
1857                     {
1858                       case 0x00:
1859                         goto op_semantics_16;
1860                         break;
1861                     }
1862                   break;
1863                 case 0x11:
1864                     GETBYTE ();
1865                     switch (op[3] & 0x00)
1866                     {
1867                       case 0x00:
1868                         goto op_semantics_17;
1869                         break;
1870                     }
1871                   break;
1872                 case 0x15:
1873                     GETBYTE ();
1874                     switch (op[3] & 0x00)
1875                     {
1876                       case 0x00:
1877                         goto op_semantics_18;
1878                         break;
1879                     }
1880                   break;
1881                 default: UNSUPPORTED(); break;
1882               }
1883             break;
1884           case 0x61:
1885               GETBYTE ();
1886               switch (op[2] & 0xff)
1887               {
1888                 case 0x00:
1889                     GETBYTE ();
1890                     switch (op[3] & 0x00)
1891                     {
1892                       case 0x00:
1893                         goto op_semantics_7;
1894                         break;
1895                     }
1896                   break;
1897                 case 0x04:
1898                     GETBYTE ();
1899                     switch (op[3] & 0x00)
1900                     {
1901                       case 0x00:
1902                         goto op_semantics_8;
1903                         break;
1904                     }
1905                   break;
1906                 case 0x05:
1907                     GETBYTE ();
1908                     switch (op[3] & 0x00)
1909                     {
1910                       case 0x00:
1911                         goto op_semantics_9;
1912                         break;
1913                     }
1914                   break;
1915                 case 0x06:
1916                     GETBYTE ();
1917                     switch (op[3] & 0x00)
1918                     {
1919                       case 0x00:
1920                         goto op_semantics_10;
1921                         break;
1922                     }
1923                   break;
1924                 case 0x07:
1925                     GETBYTE ();
1926                     switch (op[3] & 0x00)
1927                     {
1928                       case 0x00:
1929                         goto op_semantics_11;
1930                         break;
1931                     }
1932                   break;
1933                 case 0x08:
1934                     GETBYTE ();
1935                     switch (op[3] & 0x00)
1936                     {
1937                       case 0x00:
1938                         goto op_semantics_12;
1939                         break;
1940                     }
1941                   break;
1942                 case 0x09:
1943                     GETBYTE ();
1944                     switch (op[3] & 0x00)
1945                     {
1946                       case 0x00:
1947                         goto op_semantics_13;
1948                         break;
1949                     }
1950                   break;
1951                 case 0x0c:
1952                     GETBYTE ();
1953                     switch (op[3] & 0x00)
1954                     {
1955                       case 0x00:
1956                         goto op_semantics_14;
1957                         break;
1958                     }
1959                   break;
1960                 case 0x0d:
1961                     GETBYTE ();
1962                     switch (op[3] & 0x00)
1963                     {
1964                       case 0x00:
1965                         goto op_semantics_15;
1966                         break;
1967                     }
1968                   break;
1969                 case 0x10:
1970                     GETBYTE ();
1971                     switch (op[3] & 0x00)
1972                     {
1973                       case 0x00:
1974                         goto op_semantics_16;
1975                         break;
1976                     }
1977                   break;
1978                 case 0x11:
1979                     GETBYTE ();
1980                     switch (op[3] & 0x00)
1981                     {
1982                       case 0x00:
1983                         goto op_semantics_17;
1984                         break;
1985                     }
1986                   break;
1987                 case 0x15:
1988                     GETBYTE ();
1989                     switch (op[3] & 0x00)
1990                     {
1991                       case 0x00:
1992                         goto op_semantics_18;
1993                         break;
1994                     }
1995                   break;
1996                 default: UNSUPPORTED(); break;
1997               }
1998             break;
1999           case 0x62:
2000               GETBYTE ();
2001               switch (op[2] & 0xff)
2002               {
2003                 case 0x00:
2004                     GETBYTE ();
2005                     switch (op[3] & 0x00)
2006                     {
2007                       case 0x00:
2008                         goto op_semantics_7;
2009                         break;
2010                     }
2011                   break;
2012                 case 0x04:
2013                     GETBYTE ();
2014                     switch (op[3] & 0x00)
2015                     {
2016                       case 0x00:
2017                         goto op_semantics_8;
2018                         break;
2019                     }
2020                   break;
2021                 case 0x05:
2022                     GETBYTE ();
2023                     switch (op[3] & 0x00)
2024                     {
2025                       case 0x00:
2026                         goto op_semantics_9;
2027                         break;
2028                     }
2029                   break;
2030                 case 0x06:
2031                     GETBYTE ();
2032                     switch (op[3] & 0x00)
2033                     {
2034                       case 0x00:
2035                         goto op_semantics_10;
2036                         break;
2037                     }
2038                   break;
2039                 case 0x07:
2040                     GETBYTE ();
2041                     switch (op[3] & 0x00)
2042                     {
2043                       case 0x00:
2044                         goto op_semantics_11;
2045                         break;
2046                     }
2047                   break;
2048                 case 0x08:
2049                     GETBYTE ();
2050                     switch (op[3] & 0x00)
2051                     {
2052                       case 0x00:
2053                         goto op_semantics_12;
2054                         break;
2055                     }
2056                   break;
2057                 case 0x09:
2058                     GETBYTE ();
2059                     switch (op[3] & 0x00)
2060                     {
2061                       case 0x00:
2062                         goto op_semantics_13;
2063                         break;
2064                     }
2065                   break;
2066                 case 0x0c:
2067                     GETBYTE ();
2068                     switch (op[3] & 0x00)
2069                     {
2070                       case 0x00:
2071                         goto op_semantics_14;
2072                         break;
2073                     }
2074                   break;
2075                 case 0x0d:
2076                     GETBYTE ();
2077                     switch (op[3] & 0x00)
2078                     {
2079                       case 0x00:
2080                         goto op_semantics_15;
2081                         break;
2082                     }
2083                   break;
2084                 case 0x10:
2085                     GETBYTE ();
2086                     switch (op[3] & 0x00)
2087                     {
2088                       case 0x00:
2089                         goto op_semantics_16;
2090                         break;
2091                     }
2092                   break;
2093                 case 0x11:
2094                     GETBYTE ();
2095                     switch (op[3] & 0x00)
2096                     {
2097                       case 0x00:
2098                         goto op_semantics_17;
2099                         break;
2100                     }
2101                   break;
2102                 case 0x15:
2103                     GETBYTE ();
2104                     switch (op[3] & 0x00)
2105                     {
2106                       case 0x00:
2107                         goto op_semantics_18;
2108                         break;
2109                     }
2110                   break;
2111                 default: UNSUPPORTED(); break;
2112               }
2113             break;
2114           case 0x63:
2115               GETBYTE ();
2116               switch (op[2] & 0xff)
2117               {
2118                 case 0x00:
2119                     GETBYTE ();
2120                     switch (op[3] & 0x00)
2121                     {
2122                       case 0x00:
2123                         goto op_semantics_7;
2124                         break;
2125                     }
2126                   break;
2127                 case 0x04:
2128                     GETBYTE ();
2129                     switch (op[3] & 0x00)
2130                     {
2131                       case 0x00:
2132                         goto op_semantics_8;
2133                         break;
2134                     }
2135                   break;
2136                 case 0x05:
2137                     GETBYTE ();
2138                     switch (op[3] & 0x00)
2139                     {
2140                       case 0x00:
2141                         goto op_semantics_9;
2142                         break;
2143                     }
2144                   break;
2145                 case 0x06:
2146                     GETBYTE ();
2147                     switch (op[3] & 0x00)
2148                     {
2149                       case 0x00:
2150                         goto op_semantics_10;
2151                         break;
2152                     }
2153                   break;
2154                 case 0x07:
2155                     GETBYTE ();
2156                     switch (op[3] & 0x00)
2157                     {
2158                       case 0x00:
2159                         goto op_semantics_11;
2160                         break;
2161                     }
2162                   break;
2163                 case 0x08:
2164                     GETBYTE ();
2165                     switch (op[3] & 0x00)
2166                     {
2167                       case 0x00:
2168                         goto op_semantics_12;
2169                         break;
2170                     }
2171                   break;
2172                 case 0x09:
2173                     GETBYTE ();
2174                     switch (op[3] & 0x00)
2175                     {
2176                       case 0x00:
2177                         goto op_semantics_13;
2178                         break;
2179                     }
2180                   break;
2181                 case 0x0c:
2182                     GETBYTE ();
2183                     switch (op[3] & 0x00)
2184                     {
2185                       case 0x00:
2186                         goto op_semantics_14;
2187                         break;
2188                     }
2189                   break;
2190                 case 0x0d:
2191                     GETBYTE ();
2192                     switch (op[3] & 0x00)
2193                     {
2194                       case 0x00:
2195                         goto op_semantics_15;
2196                         break;
2197                     }
2198                   break;
2199                 case 0x10:
2200                     GETBYTE ();
2201                     switch (op[3] & 0x00)
2202                     {
2203                       case 0x00:
2204                         goto op_semantics_16;
2205                         break;
2206                     }
2207                   break;
2208                 case 0x11:
2209                     GETBYTE ();
2210                     switch (op[3] & 0x00)
2211                     {
2212                       case 0x00:
2213                         goto op_semantics_17;
2214                         break;
2215                     }
2216                   break;
2217                 case 0x15:
2218                     GETBYTE ();
2219                     switch (op[3] & 0x00)
2220                     {
2221                       case 0x00:
2222                         goto op_semantics_18;
2223                         break;
2224                     }
2225                   break;
2226                 default: UNSUPPORTED(); break;
2227               }
2228             break;
2229           case 0x80:
2230               GETBYTE ();
2231               switch (op[2] & 0x00)
2232               {
2233                 case 0x00:
2234                   goto op_semantics_1;
2235                   break;
2236               }
2237             break;
2238           case 0x81:
2239               GETBYTE ();
2240               switch (op[2] & 0x00)
2241               {
2242                 case 0x00:
2243                   goto op_semantics_1;
2244                   break;
2245               }
2246             break;
2247           case 0x82:
2248               GETBYTE ();
2249               switch (op[2] & 0x00)
2250               {
2251                 case 0x00:
2252                   goto op_semantics_1;
2253                   break;
2254               }
2255             break;
2256           case 0x83:
2257               GETBYTE ();
2258               switch (op[2] & 0x00)
2259               {
2260                 case 0x00:
2261                   goto op_semantics_1;
2262                   break;
2263               }
2264             break;
2265           case 0x84:
2266               GETBYTE ();
2267               switch (op[2] & 0x00)
2268               {
2269                 case 0x00:
2270                   goto op_semantics_2;
2271                   break;
2272               }
2273             break;
2274           case 0x85:
2275               GETBYTE ();
2276               switch (op[2] & 0x00)
2277               {
2278                 case 0x00:
2279                   goto op_semantics_2;
2280                   break;
2281               }
2282             break;
2283           case 0x86:
2284               GETBYTE ();
2285               switch (op[2] & 0x00)
2286               {
2287                 case 0x00:
2288                   goto op_semantics_2;
2289                   break;
2290               }
2291             break;
2292           case 0x87:
2293               GETBYTE ();
2294               switch (op[2] & 0x00)
2295               {
2296                 case 0x00:
2297                   goto op_semantics_2;
2298                   break;
2299               }
2300             break;
2301           case 0x88:
2302               GETBYTE ();
2303               switch (op[2] & 0x00)
2304               {
2305                 case 0x00:
2306                   goto op_semantics_3;
2307                   break;
2308               }
2309             break;
2310           case 0x89:
2311               GETBYTE ();
2312               switch (op[2] & 0x00)
2313               {
2314                 case 0x00:
2315                   goto op_semantics_3;
2316                   break;
2317               }
2318             break;
2319           case 0x8a:
2320               GETBYTE ();
2321               switch (op[2] & 0x00)
2322               {
2323                 case 0x00:
2324                   goto op_semantics_3;
2325                   break;
2326               }
2327             break;
2328           case 0x8b:
2329               GETBYTE ();
2330               switch (op[2] & 0x00)
2331               {
2332                 case 0x00:
2333                   goto op_semantics_3;
2334                   break;
2335               }
2336             break;
2337           case 0x8c:
2338               GETBYTE ();
2339               switch (op[2] & 0x00)
2340               {
2341                 case 0x00:
2342                   goto op_semantics_4;
2343                   break;
2344               }
2345             break;
2346           case 0x8d:
2347               GETBYTE ();
2348               switch (op[2] & 0x00)
2349               {
2350                 case 0x00:
2351                   goto op_semantics_4;
2352                   break;
2353               }
2354             break;
2355           case 0x8e:
2356               GETBYTE ();
2357               switch (op[2] & 0x00)
2358               {
2359                 case 0x00:
2360                   goto op_semantics_4;
2361                   break;
2362               }
2363             break;
2364           case 0x8f:
2365               GETBYTE ();
2366               switch (op[2] & 0x00)
2367               {
2368                 case 0x00:
2369                   goto op_semantics_4;
2370                   break;
2371               }
2372             break;
2373           case 0x90:
2374               GETBYTE ();
2375               switch (op[2] & 0x00)
2376               {
2377                 case 0x00:
2378                   goto op_semantics_5;
2379                   break;
2380               }
2381             break;
2382           case 0x91:
2383               GETBYTE ();
2384               switch (op[2] & 0x00)
2385               {
2386                 case 0x00:
2387                   goto op_semantics_5;
2388                   break;
2389               }
2390             break;
2391           case 0x92:
2392               GETBYTE ();
2393               switch (op[2] & 0x00)
2394               {
2395                 case 0x00:
2396                   goto op_semantics_5;
2397                   break;
2398               }
2399             break;
2400           case 0x93:
2401               GETBYTE ();
2402               switch (op[2] & 0x00)
2403               {
2404                 case 0x00:
2405                   goto op_semantics_5;
2406                   break;
2407               }
2408             break;
2409           case 0x94:
2410               GETBYTE ();
2411               switch (op[2] & 0x00)
2412               {
2413                 case 0x00:
2414                   goto op_semantics_6;
2415                   break;
2416               }
2417             break;
2418           case 0x95:
2419               GETBYTE ();
2420               switch (op[2] & 0x00)
2421               {
2422                 case 0x00:
2423                   goto op_semantics_6;
2424                   break;
2425               }
2426             break;
2427           case 0x96:
2428               GETBYTE ();
2429               switch (op[2] & 0x00)
2430               {
2431                 case 0x00:
2432                   goto op_semantics_6;
2433                   break;
2434               }
2435             break;
2436           case 0x97:
2437               GETBYTE ();
2438               switch (op[2] & 0x00)
2439               {
2440                 case 0x00:
2441                   goto op_semantics_6;
2442                   break;
2443               }
2444             break;
2445           case 0xa0:
2446               GETBYTE ();
2447               switch (op[2] & 0xff)
2448               {
2449                 case 0x00:
2450                     GETBYTE ();
2451                     switch (op[3] & 0x00)
2452                     {
2453                       case 0x00:
2454                         goto op_semantics_7;
2455                         break;
2456                     }
2457                   break;
2458                 case 0x02:
2459                     GETBYTE ();
2460                     switch (op[3] & 0x00)
2461                     {
2462                       case 0x00:
2463                         op_semantics_19:
2464                           {
2465                             /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc     %1%S1, %0 */
2466 #line 498 "rx-decode.opc"
2467                             int ss AU = op[1] & 0x03;
2468 #line 498 "rx-decode.opc"
2469                             int rsrc AU = (op[3] >> 4) & 0x0f;
2470 #line 498 "rx-decode.opc"
2471                             int rdst AU = op[3] & 0x0f;
2472                             if (trace)
2473                               {
2474                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
2475                                        "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst     adc     %1%S1, %0 */",
2476                                        op[0], op[1], op[2], op[3]);
2477                                 printf ("  ss = 0x%x,", ss);
2478                                 printf ("  rsrc = 0x%x,", rsrc);
2479                                 printf ("  rdst = 0x%x\n", rdst);
2480                               }
2481                             SYNTAX("adc %1%S1, %0");
2482 #line 498 "rx-decode.opc"
2483                             ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2484
2485                           /*----------------------------------------------------------------------*/
2486                           /* ADD                                                                        */
2487
2488                           }
2489                         break;
2490                     }
2491                   break;
2492                 case 0x04:
2493                     GETBYTE ();
2494                     switch (op[3] & 0x00)
2495                     {
2496                       case 0x00:
2497                         goto op_semantics_8;
2498                         break;
2499                     }
2500                   break;
2501                 case 0x05:
2502                     GETBYTE ();
2503                     switch (op[3] & 0x00)
2504                     {
2505                       case 0x00:
2506                         goto op_semantics_9;
2507                         break;
2508                     }
2509                   break;
2510                 case 0x06:
2511                     GETBYTE ();
2512                     switch (op[3] & 0x00)
2513                     {
2514                       case 0x00:
2515                         goto op_semantics_10;
2516                         break;
2517                     }
2518                   break;
2519                 case 0x07:
2520                     GETBYTE ();
2521                     switch (op[3] & 0x00)
2522                     {
2523                       case 0x00:
2524                         goto op_semantics_11;
2525                         break;
2526                     }
2527                   break;
2528                 case 0x08:
2529                     GETBYTE ();
2530                     switch (op[3] & 0x00)
2531                     {
2532                       case 0x00:
2533                         goto op_semantics_12;
2534                         break;
2535                     }
2536                   break;
2537                 case 0x09:
2538                     GETBYTE ();
2539                     switch (op[3] & 0x00)
2540                     {
2541                       case 0x00:
2542                         goto op_semantics_13;
2543                         break;
2544                     }
2545                   break;
2546                 case 0x0c:
2547                     GETBYTE ();
2548                     switch (op[3] & 0x00)
2549                     {
2550                       case 0x00:
2551                         goto op_semantics_14;
2552                         break;
2553                     }
2554                   break;
2555                 case 0x0d:
2556                     GETBYTE ();
2557                     switch (op[3] & 0x00)
2558                     {
2559                       case 0x00:
2560                         goto op_semantics_15;
2561                         break;
2562                     }
2563                   break;
2564                 case 0x10:
2565                     GETBYTE ();
2566                     switch (op[3] & 0x00)
2567                     {
2568                       case 0x00:
2569                         goto op_semantics_16;
2570                         break;
2571                     }
2572                   break;
2573                 case 0x11:
2574                     GETBYTE ();
2575                     switch (op[3] & 0x00)
2576                     {
2577                       case 0x00:
2578                         goto op_semantics_17;
2579                         break;
2580                     }
2581                   break;
2582                 case 0x15:
2583                     GETBYTE ();
2584                     switch (op[3] & 0x00)
2585                     {
2586                       case 0x00:
2587                         goto op_semantics_18;
2588                         break;
2589                     }
2590                   break;
2591                 default: UNSUPPORTED(); break;
2592               }
2593             break;
2594           case 0xa1:
2595               GETBYTE ();
2596               switch (op[2] & 0xff)
2597               {
2598                 case 0x00:
2599                     GETBYTE ();
2600                     switch (op[3] & 0x00)
2601                     {
2602                       case 0x00:
2603                         goto op_semantics_7;
2604                         break;
2605                     }
2606                   break;
2607                 case 0x02:
2608                     GETBYTE ();
2609                     switch (op[3] & 0x00)
2610                     {
2611                       case 0x00:
2612                         goto op_semantics_19;
2613                         break;
2614                     }
2615                   break;
2616                 case 0x04:
2617                     GETBYTE ();
2618                     switch (op[3] & 0x00)
2619                     {
2620                       case 0x00:
2621                         goto op_semantics_8;
2622                         break;
2623                     }
2624                   break;
2625                 case 0x05:
2626                     GETBYTE ();
2627                     switch (op[3] & 0x00)
2628                     {
2629                       case 0x00:
2630                         goto op_semantics_9;
2631                         break;
2632                     }
2633                   break;
2634                 case 0x06:
2635                     GETBYTE ();
2636                     switch (op[3] & 0x00)
2637                     {
2638                       case 0x00:
2639                         goto op_semantics_10;
2640                         break;
2641                     }
2642                   break;
2643                 case 0x07:
2644                     GETBYTE ();
2645                     switch (op[3] & 0x00)
2646                     {
2647                       case 0x00:
2648                         goto op_semantics_11;
2649                         break;
2650                     }
2651                   break;
2652                 case 0x08:
2653                     GETBYTE ();
2654                     switch (op[3] & 0x00)
2655                     {
2656                       case 0x00:
2657                         goto op_semantics_12;
2658                         break;
2659                     }
2660                   break;
2661                 case 0x09:
2662                     GETBYTE ();
2663                     switch (op[3] & 0x00)
2664                     {
2665                       case 0x00:
2666                         goto op_semantics_13;
2667                         break;
2668                     }
2669                   break;
2670                 case 0x0c:
2671                     GETBYTE ();
2672                     switch (op[3] & 0x00)
2673                     {
2674                       case 0x00:
2675                         goto op_semantics_14;
2676                         break;
2677                     }
2678                   break;
2679                 case 0x0d:
2680                     GETBYTE ();
2681                     switch (op[3] & 0x00)
2682                     {
2683                       case 0x00:
2684                         goto op_semantics_15;
2685                         break;
2686                     }
2687                   break;
2688                 case 0x10:
2689                     GETBYTE ();
2690                     switch (op[3] & 0x00)
2691                     {
2692                       case 0x00:
2693                         goto op_semantics_16;
2694                         break;
2695                     }
2696                   break;
2697                 case 0x11:
2698                     GETBYTE ();
2699                     switch (op[3] & 0x00)
2700                     {
2701                       case 0x00:
2702                         goto op_semantics_17;
2703                         break;
2704                     }
2705                   break;
2706                 case 0x15:
2707                     GETBYTE ();
2708                     switch (op[3] & 0x00)
2709                     {
2710                       case 0x00:
2711                         goto op_semantics_18;
2712                         break;
2713                     }
2714                   break;
2715                 default: UNSUPPORTED(); break;
2716               }
2717             break;
2718           case 0xa2:
2719               GETBYTE ();
2720               switch (op[2] & 0xff)
2721               {
2722                 case 0x00:
2723                     GETBYTE ();
2724                     switch (op[3] & 0x00)
2725                     {
2726                       case 0x00:
2727                         goto op_semantics_7;
2728                         break;
2729                     }
2730                   break;
2731                 case 0x02:
2732                     GETBYTE ();
2733                     switch (op[3] & 0x00)
2734                     {
2735                       case 0x00:
2736                         goto op_semantics_19;
2737                         break;
2738                     }
2739                   break;
2740                 case 0x04:
2741                     GETBYTE ();
2742                     switch (op[3] & 0x00)
2743                     {
2744                       case 0x00:
2745                         goto op_semantics_8;
2746                         break;
2747                     }
2748                   break;
2749                 case 0x05:
2750                     GETBYTE ();
2751                     switch (op[3] & 0x00)
2752                     {
2753                       case 0x00:
2754                         goto op_semantics_9;
2755                         break;
2756                     }
2757                   break;
2758                 case 0x06:
2759                     GETBYTE ();
2760                     switch (op[3] & 0x00)
2761                     {
2762                       case 0x00:
2763                         goto op_semantics_10;
2764                         break;
2765                     }
2766                   break;
2767                 case 0x07:
2768                     GETBYTE ();
2769                     switch (op[3] & 0x00)
2770                     {
2771                       case 0x00:
2772                         goto op_semantics_11;
2773                         break;
2774                     }
2775                   break;
2776                 case 0x08:
2777                     GETBYTE ();
2778                     switch (op[3] & 0x00)
2779                     {
2780                       case 0x00:
2781                         goto op_semantics_12;
2782                         break;
2783                     }
2784                   break;
2785                 case 0x09:
2786                     GETBYTE ();
2787                     switch (op[3] & 0x00)
2788                     {
2789                       case 0x00:
2790                         goto op_semantics_13;
2791                         break;
2792                     }
2793                   break;
2794                 case 0x0c:
2795                     GETBYTE ();
2796                     switch (op[3] & 0x00)
2797                     {
2798                       case 0x00:
2799                         goto op_semantics_14;
2800                         break;
2801                     }
2802                   break;
2803                 case 0x0d:
2804                     GETBYTE ();
2805                     switch (op[3] & 0x00)
2806                     {
2807                       case 0x00:
2808                         goto op_semantics_15;
2809                         break;
2810                     }
2811                   break;
2812                 case 0x10:
2813                     GETBYTE ();
2814                     switch (op[3] & 0x00)
2815                     {
2816                       case 0x00:
2817                         goto op_semantics_16;
2818                         break;
2819                     }
2820                   break;
2821                 case 0x11:
2822                     GETBYTE ();
2823                     switch (op[3] & 0x00)
2824                     {
2825                       case 0x00:
2826                         goto op_semantics_17;
2827                         break;
2828                     }
2829                   break;
2830                 case 0x15:
2831                     GETBYTE ();
2832                     switch (op[3] & 0x00)
2833                     {
2834                       case 0x00:
2835                         goto op_semantics_18;
2836                         break;
2837                     }
2838                   break;
2839                 default: UNSUPPORTED(); break;
2840               }
2841             break;
2842           case 0xa3:
2843               GETBYTE ();
2844               switch (op[2] & 0xff)
2845               {
2846                 case 0x00:
2847                     GETBYTE ();
2848                     switch (op[3] & 0x00)
2849                     {
2850                       case 0x00:
2851                         goto op_semantics_7;
2852                         break;
2853                     }
2854                   break;
2855                 case 0x02:
2856                     GETBYTE ();
2857                     switch (op[3] & 0x00)
2858                     {
2859                       case 0x00:
2860                         goto op_semantics_19;
2861                         break;
2862                     }
2863                   break;
2864                 case 0x04:
2865                     GETBYTE ();
2866                     switch (op[3] & 0x00)
2867                     {
2868                       case 0x00:
2869                         goto op_semantics_8;
2870                         break;
2871                     }
2872                   break;
2873                 case 0x05:
2874                     GETBYTE ();
2875                     switch (op[3] & 0x00)
2876                     {
2877                       case 0x00:
2878                         goto op_semantics_9;
2879                         break;
2880                     }
2881                   break;
2882                 case 0x06:
2883                     GETBYTE ();
2884                     switch (op[3] & 0x00)
2885                     {
2886                       case 0x00:
2887                         goto op_semantics_10;
2888                         break;
2889                     }
2890                   break;
2891                 case 0x07:
2892                     GETBYTE ();
2893                     switch (op[3] & 0x00)
2894                     {
2895                       case 0x00:
2896                         goto op_semantics_11;
2897                         break;
2898                     }
2899                   break;
2900                 case 0x08:
2901                     GETBYTE ();
2902                     switch (op[3] & 0x00)
2903                     {
2904                       case 0x00:
2905                         goto op_semantics_12;
2906                         break;
2907                     }
2908                   break;
2909                 case 0x09:
2910                     GETBYTE ();
2911                     switch (op[3] & 0x00)
2912                     {
2913                       case 0x00:
2914                         goto op_semantics_13;
2915                         break;
2916                     }
2917                   break;
2918                 case 0x0c:
2919                     GETBYTE ();
2920                     switch (op[3] & 0x00)
2921                     {
2922                       case 0x00:
2923                         goto op_semantics_14;
2924                         break;
2925                     }
2926                   break;
2927                 case 0x0d:
2928                     GETBYTE ();
2929                     switch (op[3] & 0x00)
2930                     {
2931                       case 0x00:
2932                         goto op_semantics_15;
2933                         break;
2934                     }
2935                   break;
2936                 case 0x10:
2937                     GETBYTE ();
2938                     switch (op[3] & 0x00)
2939                     {
2940                       case 0x00:
2941                         goto op_semantics_16;
2942                         break;
2943                     }
2944                   break;
2945                 case 0x11:
2946                     GETBYTE ();
2947                     switch (op[3] & 0x00)
2948                     {
2949                       case 0x00:
2950                         goto op_semantics_17;
2951                         break;
2952                     }
2953                   break;
2954                 case 0x15:
2955                     GETBYTE ();
2956                     switch (op[3] & 0x00)
2957                     {
2958                       case 0x00:
2959                         goto op_semantics_18;
2960                         break;
2961                     }
2962                   break;
2963                 default: UNSUPPORTED(); break;
2964               }
2965             break;
2966           case 0xc0:
2967               GETBYTE ();
2968               switch (op[2] & 0x00)
2969               {
2970                 case 0x00:
2971                   goto op_semantics_1;
2972                   break;
2973               }
2974             break;
2975           case 0xc1:
2976               GETBYTE ();
2977               switch (op[2] & 0x00)
2978               {
2979                 case 0x00:
2980                   goto op_semantics_1;
2981                   break;
2982               }
2983             break;
2984           case 0xc2:
2985               GETBYTE ();
2986               switch (op[2] & 0x00)
2987               {
2988                 case 0x00:
2989                   goto op_semantics_1;
2990                   break;
2991               }
2992             break;
2993           case 0xc3:
2994               GETBYTE ();
2995               switch (op[2] & 0x00)
2996               {
2997                 case 0x00:
2998                   goto op_semantics_1;
2999                   break;
3000               }
3001             break;
3002           case 0xc4:
3003               GETBYTE ();
3004               switch (op[2] & 0x00)
3005               {
3006                 case 0x00:
3007                   goto op_semantics_2;
3008                   break;
3009               }
3010             break;
3011           case 0xc5:
3012               GETBYTE ();
3013               switch (op[2] & 0x00)
3014               {
3015                 case 0x00:
3016                   goto op_semantics_2;
3017                   break;
3018               }
3019             break;
3020           case 0xc6:
3021               GETBYTE ();
3022               switch (op[2] & 0x00)
3023               {
3024                 case 0x00:
3025                   goto op_semantics_2;
3026                   break;
3027               }
3028             break;
3029           case 0xc7:
3030               GETBYTE ();
3031               switch (op[2] & 0x00)
3032               {
3033                 case 0x00:
3034                   goto op_semantics_2;
3035                   break;
3036               }
3037             break;
3038           case 0xc8:
3039               GETBYTE ();
3040               switch (op[2] & 0x00)
3041               {
3042                 case 0x00:
3043                   goto op_semantics_3;
3044                   break;
3045               }
3046             break;
3047           case 0xc9:
3048               GETBYTE ();
3049               switch (op[2] & 0x00)
3050               {
3051                 case 0x00:
3052                   goto op_semantics_3;
3053                   break;
3054               }
3055             break;
3056           case 0xca:
3057               GETBYTE ();
3058               switch (op[2] & 0x00)
3059               {
3060                 case 0x00:
3061                   goto op_semantics_3;
3062                   break;
3063               }
3064             break;
3065           case 0xcb:
3066               GETBYTE ();
3067               switch (op[2] & 0x00)
3068               {
3069                 case 0x00:
3070                   goto op_semantics_3;
3071                   break;
3072               }
3073             break;
3074           case 0xcc:
3075               GETBYTE ();
3076               switch (op[2] & 0x00)
3077               {
3078                 case 0x00:
3079                   goto op_semantics_4;
3080                   break;
3081               }
3082             break;
3083           case 0xcd:
3084               GETBYTE ();
3085               switch (op[2] & 0x00)
3086               {
3087                 case 0x00:
3088                   goto op_semantics_4;
3089                   break;
3090               }
3091             break;
3092           case 0xce:
3093               GETBYTE ();
3094               switch (op[2] & 0x00)
3095               {
3096                 case 0x00:
3097                   goto op_semantics_4;
3098                   break;
3099               }
3100             break;
3101           case 0xcf:
3102               GETBYTE ();
3103               switch (op[2] & 0x00)
3104               {
3105                 case 0x00:
3106                   goto op_semantics_4;
3107                   break;
3108               }
3109             break;
3110           case 0xd0:
3111               GETBYTE ();
3112               switch (op[2] & 0x00)
3113               {
3114                 case 0x00:
3115                   goto op_semantics_5;
3116                   break;
3117               }
3118             break;
3119           case 0xd1:
3120               GETBYTE ();
3121               switch (op[2] & 0x00)
3122               {
3123                 case 0x00:
3124                   goto op_semantics_5;
3125                   break;
3126               }
3127             break;
3128           case 0xd2:
3129               GETBYTE ();
3130               switch (op[2] & 0x00)
3131               {
3132                 case 0x00:
3133                   goto op_semantics_5;
3134                   break;
3135               }
3136             break;
3137           case 0xd3:
3138               GETBYTE ();
3139               switch (op[2] & 0x00)
3140               {
3141                 case 0x00:
3142                   goto op_semantics_5;
3143                   break;
3144               }
3145             break;
3146           case 0xd4:
3147               GETBYTE ();
3148               switch (op[2] & 0x00)
3149               {
3150                 case 0x00:
3151                   goto op_semantics_6;
3152                   break;
3153               }
3154             break;
3155           case 0xd5:
3156               GETBYTE ();
3157               switch (op[2] & 0x00)
3158               {
3159                 case 0x00:
3160                   goto op_semantics_6;
3161                   break;
3162               }
3163             break;
3164           case 0xd6:
3165               GETBYTE ();
3166               switch (op[2] & 0x00)
3167               {
3168                 case 0x00:
3169                   goto op_semantics_6;
3170                   break;
3171               }
3172             break;
3173           case 0xd7:
3174               GETBYTE ();
3175               switch (op[2] & 0x00)
3176               {
3177                 case 0x00:
3178                   goto op_semantics_6;
3179                   break;
3180               }
3181             break;
3182           case 0xe0:
3183               GETBYTE ();
3184               switch (op[2] & 0xff)
3185               {
3186                 case 0x00:
3187                     GETBYTE ();
3188                     switch (op[3] & 0x00)
3189                     {
3190                       case 0x00:
3191                         goto op_semantics_7;
3192                         break;
3193                     }
3194                   break;
3195                 case 0x04:
3196                     GETBYTE ();
3197                     switch (op[3] & 0x00)
3198                     {
3199                       case 0x00:
3200                         goto op_semantics_8;
3201                         break;
3202                     }
3203                   break;
3204                 case 0x05:
3205                     GETBYTE ();
3206                     switch (op[3] & 0x00)
3207                     {
3208                       case 0x00:
3209                         goto op_semantics_9;
3210                         break;
3211                     }
3212                   break;
3213                 case 0x06:
3214                     GETBYTE ();
3215                     switch (op[3] & 0x00)
3216                     {
3217                       case 0x00:
3218                         goto op_semantics_10;
3219                         break;
3220                     }
3221                   break;
3222                 case 0x07:
3223                     GETBYTE ();
3224                     switch (op[3] & 0x00)
3225                     {
3226                       case 0x00:
3227                         goto op_semantics_11;
3228                         break;
3229                     }
3230                   break;
3231                 case 0x08:
3232                     GETBYTE ();
3233                     switch (op[3] & 0x00)
3234                     {
3235                       case 0x00:
3236                         goto op_semantics_12;
3237                         break;
3238                     }
3239                   break;
3240                 case 0x09:
3241                     GETBYTE ();
3242                     switch (op[3] & 0x00)
3243                     {
3244                       case 0x00:
3245                         goto op_semantics_13;
3246                         break;
3247                     }
3248                   break;
3249                 case 0x0c:
3250                     GETBYTE ();
3251                     switch (op[3] & 0x00)
3252                     {
3253                       case 0x00:
3254                         goto op_semantics_14;
3255                         break;
3256                     }
3257                   break;
3258                 case 0x0d:
3259                     GETBYTE ();
3260                     switch (op[3] & 0x00)
3261                     {
3262                       case 0x00:
3263                         goto op_semantics_15;
3264                         break;
3265                     }
3266                   break;
3267                 case 0x10:
3268                     GETBYTE ();
3269                     switch (op[3] & 0x00)
3270                     {
3271                       case 0x00:
3272                         goto op_semantics_16;
3273                         break;
3274                     }
3275                   break;
3276                 case 0x11:
3277                     GETBYTE ();
3278                     switch (op[3] & 0x00)
3279                     {
3280                       case 0x00:
3281                         goto op_semantics_17;
3282                         break;
3283                     }
3284                   break;
3285                 case 0x15:
3286                     GETBYTE ();
3287                     switch (op[3] & 0x00)
3288                     {
3289                       case 0x00:
3290                         goto op_semantics_18;
3291                         break;
3292                     }
3293                   break;
3294                 default: UNSUPPORTED(); break;
3295               }
3296             break;
3297           case 0xe1:
3298               GETBYTE ();
3299               switch (op[2] & 0xff)
3300               {
3301                 case 0x00:
3302                     GETBYTE ();
3303                     switch (op[3] & 0x00)
3304                     {
3305                       case 0x00:
3306                         goto op_semantics_7;
3307                         break;
3308                     }
3309                   break;
3310                 case 0x04:
3311                     GETBYTE ();
3312                     switch (op[3] & 0x00)
3313                     {
3314                       case 0x00:
3315                         goto op_semantics_8;
3316                         break;
3317                     }
3318                   break;
3319                 case 0x05:
3320                     GETBYTE ();
3321                     switch (op[3] & 0x00)
3322                     {
3323                       case 0x00:
3324                         goto op_semantics_9;
3325                         break;
3326                     }
3327                   break;
3328                 case 0x06:
3329                     GETBYTE ();
3330                     switch (op[3] & 0x00)
3331                     {
3332                       case 0x00:
3333                         goto op_semantics_10;
3334                         break;
3335                     }
3336                   break;
3337                 case 0x07:
3338                     GETBYTE ();
3339                     switch (op[3] & 0x00)
3340                     {
3341                       case 0x00:
3342                         goto op_semantics_11;
3343                         break;
3344                     }
3345                   break;
3346                 case 0x08:
3347                     GETBYTE ();
3348                     switch (op[3] & 0x00)
3349                     {
3350                       case 0x00:
3351                         goto op_semantics_12;
3352                         break;
3353                     }
3354                   break;
3355                 case 0x09:
3356                     GETBYTE ();
3357                     switch (op[3] & 0x00)
3358                     {
3359                       case 0x00:
3360                         goto op_semantics_13;
3361                         break;
3362                     }
3363                   break;
3364                 case 0x0c:
3365                     GETBYTE ();
3366                     switch (op[3] & 0x00)
3367                     {
3368                       case 0x00:
3369                         goto op_semantics_14;
3370                         break;
3371                     }
3372                   break;
3373                 case 0x0d:
3374                     GETBYTE ();
3375                     switch (op[3] & 0x00)
3376                     {
3377                       case 0x00:
3378                         goto op_semantics_15;
3379                         break;
3380                     }
3381                   break;
3382                 case 0x10:
3383                     GETBYTE ();
3384                     switch (op[3] & 0x00)
3385                     {
3386                       case 0x00:
3387                         goto op_semantics_16;
3388                         break;
3389                     }
3390                   break;
3391                 case 0x11:
3392                     GETBYTE ();
3393                     switch (op[3] & 0x00)
3394                     {
3395                       case 0x00:
3396                         goto op_semantics_17;
3397                         break;
3398                     }
3399                   break;
3400                 case 0x15:
3401                     GETBYTE ();
3402                     switch (op[3] & 0x00)
3403                     {
3404                       case 0x00:
3405                         goto op_semantics_18;
3406                         break;
3407                     }
3408                   break;
3409                 default: UNSUPPORTED(); break;
3410               }
3411             break;
3412           case 0xe2:
3413               GETBYTE ();
3414               switch (op[2] & 0xff)
3415               {
3416                 case 0x00:
3417                     GETBYTE ();
3418                     switch (op[3] & 0x00)
3419                     {
3420                       case 0x00:
3421                         goto op_semantics_7;
3422                         break;
3423                     }
3424                   break;
3425                 case 0x04:
3426                     GETBYTE ();
3427                     switch (op[3] & 0x00)
3428                     {
3429                       case 0x00:
3430                         goto op_semantics_8;
3431                         break;
3432                     }
3433                   break;
3434                 case 0x05:
3435                     GETBYTE ();
3436                     switch (op[3] & 0x00)
3437                     {
3438                       case 0x00:
3439                         goto op_semantics_9;
3440                         break;
3441                     }
3442                   break;
3443                 case 0x06:
3444                     GETBYTE ();
3445                     switch (op[3] & 0x00)
3446                     {
3447                       case 0x00:
3448                         goto op_semantics_10;
3449                         break;
3450                     }
3451                   break;
3452                 case 0x07:
3453                     GETBYTE ();
3454                     switch (op[3] & 0x00)
3455                     {
3456                       case 0x00:
3457                         goto op_semantics_11;
3458                         break;
3459                     }
3460                   break;
3461                 case 0x08:
3462                     GETBYTE ();
3463                     switch (op[3] & 0x00)
3464                     {
3465                       case 0x00:
3466                         goto op_semantics_12;
3467                         break;
3468                     }
3469                   break;
3470                 case 0x09:
3471                     GETBYTE ();
3472                     switch (op[3] & 0x00)
3473                     {
3474                       case 0x00:
3475                         goto op_semantics_13;
3476                         break;
3477                     }
3478                   break;
3479                 case 0x0c:
3480                     GETBYTE ();
3481                     switch (op[3] & 0x00)
3482                     {
3483                       case 0x00:
3484                         goto op_semantics_14;
3485                         break;
3486                     }
3487                   break;
3488                 case 0x0d:
3489                     GETBYTE ();
3490                     switch (op[3] & 0x00)
3491                     {
3492                       case 0x00:
3493                         goto op_semantics_15;
3494                         break;
3495                     }
3496                   break;
3497                 case 0x10:
3498                     GETBYTE ();
3499                     switch (op[3] & 0x00)
3500                     {
3501                       case 0x00:
3502                         goto op_semantics_16;
3503                         break;
3504                     }
3505                   break;
3506                 case 0x11:
3507                     GETBYTE ();
3508                     switch (op[3] & 0x00)
3509                     {
3510                       case 0x00:
3511                         goto op_semantics_17;
3512                         break;
3513                     }
3514                   break;
3515                 case 0x15:
3516                     GETBYTE ();
3517                     switch (op[3] & 0x00)
3518                     {
3519                       case 0x00:
3520                         goto op_semantics_18;
3521                         break;
3522                     }
3523                   break;
3524                 default: UNSUPPORTED(); break;
3525               }
3526             break;
3527           case 0xe3:
3528               GETBYTE ();
3529               switch (op[2] & 0xff)
3530               {
3531                 case 0x00:
3532                     GETBYTE ();
3533                     switch (op[3] & 0x00)
3534                     {
3535                       case 0x00:
3536                         goto op_semantics_7;
3537                         break;
3538                     }
3539                   break;
3540                 case 0x04:
3541                     GETBYTE ();
3542                     switch (op[3] & 0x00)
3543                     {
3544                       case 0x00:
3545                         goto op_semantics_8;
3546                         break;
3547                     }
3548                   break;
3549                 case 0x05:
3550                     GETBYTE ();
3551                     switch (op[3] & 0x00)
3552                     {
3553                       case 0x00:
3554                         goto op_semantics_9;
3555                         break;
3556                     }
3557                   break;
3558                 case 0x06:
3559                     GETBYTE ();
3560                     switch (op[3] & 0x00)
3561                     {
3562                       case 0x00:
3563                         goto op_semantics_10;
3564                         break;
3565                     }
3566                   break;
3567                 case 0x07:
3568                     GETBYTE ();
3569                     switch (op[3] & 0x00)
3570                     {
3571                       case 0x00:
3572                         goto op_semantics_11;
3573                         break;
3574                     }
3575                   break;
3576                 case 0x08:
3577                     GETBYTE ();
3578                     switch (op[3] & 0x00)
3579                     {
3580                       case 0x00:
3581                         goto op_semantics_12;
3582                         break;
3583                     }
3584                   break;
3585                 case 0x09:
3586                     GETBYTE ();
3587                     switch (op[3] & 0x00)
3588                     {
3589                       case 0x00:
3590                         goto op_semantics_13;
3591                         break;
3592                     }
3593                   break;
3594                 case 0x0c:
3595                     GETBYTE ();
3596                     switch (op[3] & 0x00)
3597                     {
3598                       case 0x00:
3599                         goto op_semantics_14;
3600                         break;
3601                     }
3602                   break;
3603                 case 0x0d:
3604                     GETBYTE ();
3605                     switch (op[3] & 0x00)
3606                     {
3607                       case 0x00:
3608                         goto op_semantics_15;
3609                         break;
3610                     }
3611                   break;
3612                 case 0x10:
3613                     GETBYTE ();
3614                     switch (op[3] & 0x00)
3615                     {
3616                       case 0x00:
3617                         goto op_semantics_16;
3618                         break;
3619                     }
3620                   break;
3621                 case 0x11:
3622                     GETBYTE ();
3623                     switch (op[3] & 0x00)
3624                     {
3625                       case 0x00:
3626                         goto op_semantics_17;
3627                         break;
3628                     }
3629                   break;
3630                 case 0x15:
3631                     GETBYTE ();
3632                     switch (op[3] & 0x00)
3633                     {
3634                       case 0x00:
3635                         goto op_semantics_18;
3636                         break;
3637                     }
3638                   break;
3639                 default: UNSUPPORTED(); break;
3640               }
3641             break;
3642           default: UNSUPPORTED(); break;
3643         }
3644       break;
3645     case 0x08:
3646     case 0x09:
3647     case 0x0a:
3648     case 0x0b:
3649     case 0x0c:
3650     case 0x0d:
3651     case 0x0e:
3652     case 0x0f:
3653         {
3654           /** 0000 1dsp                 bra.s   %a0 */
3655 #line 779 "rx-decode.opc"
3656           int dsp AU = op[0] & 0x07;
3657           if (trace)
3658             {
3659               printf ("\033[33m%s\033[0m  %02x\n",
3660                      "/** 0000 1dsp                     bra.s   %a0 */",
3661                      op[0]);
3662               printf ("  dsp = 0x%x\n", dsp);
3663             }
3664           SYNTAX("bra.s %a0");
3665 #line 779 "rx-decode.opc"
3666           ID(branch); DC(pc + dsp3map[dsp]);
3667
3668         }
3669       break;
3670     case 0x10:
3671     case 0x11:
3672     case 0x12:
3673     case 0x13:
3674     case 0x14:
3675     case 0x15:
3676     case 0x16:
3677     case 0x17:
3678     case 0x18:
3679     case 0x19:
3680     case 0x1a:
3681     case 0x1b:
3682     case 0x1c:
3683     case 0x1d:
3684     case 0x1e:
3685     case 0x1f:
3686         {
3687           /** 0001 n dsp                        b%1.s   %a0 */
3688 #line 769 "rx-decode.opc"
3689           int n AU = (op[0] >> 3) & 0x01;
3690 #line 769 "rx-decode.opc"
3691           int dsp AU = op[0] & 0x07;
3692           if (trace)
3693             {
3694               printf ("\033[33m%s\033[0m  %02x\n",
3695                      "/** 0001 n dsp                    b%1.s   %a0 */",
3696                      op[0]);
3697               printf ("  n = 0x%x,", n);
3698               printf ("  dsp = 0x%x\n", dsp);
3699             }
3700           SYNTAX("b%1.s %a0");
3701 #line 769 "rx-decode.opc"
3702           ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3703
3704         }
3705       break;
3706     case 0x20:
3707     case 0x21:
3708     case 0x22:
3709     case 0x23:
3710     case 0x24:
3711     case 0x25:
3712     case 0x26:
3713     case 0x27:
3714     case 0x28:
3715     case 0x29:
3716     case 0x2a:
3717     case 0x2b:
3718     case 0x2c:
3719     case 0x2d:
3720     case 0x2f:
3721         {
3722           /** 0010 cond                 b%1.b   %a0 */
3723 #line 772 "rx-decode.opc"
3724           int cond AU = op[0] & 0x0f;
3725           if (trace)
3726             {
3727               printf ("\033[33m%s\033[0m  %02x\n",
3728                      "/** 0010 cond                     b%1.b   %a0 */",
3729                      op[0]);
3730               printf ("  cond = 0x%x\n", cond);
3731             }
3732           SYNTAX("b%1.b %a0");
3733 #line 772 "rx-decode.opc"
3734           ID(branch); Scc(cond); DC(pc + IMMex (1));
3735
3736         }
3737       break;
3738     case 0x2e:
3739         {
3740           /** 0010 1110                 bra.b   %a0 */
3741           if (trace)
3742             {
3743               printf ("\033[33m%s\033[0m  %02x\n",
3744                      "/** 0010 1110                     bra.b   %a0 */",
3745                      op[0]);
3746             }
3747           SYNTAX("bra.b %a0");
3748 #line 782 "rx-decode.opc"
3749           ID(branch); DC(pc + IMMex(1));
3750
3751         }
3752       break;
3753     case 0x38:
3754         {
3755           /** 0011 1000                 bra.w   %a0 */
3756           if (trace)
3757             {
3758               printf ("\033[33m%s\033[0m  %02x\n",
3759                      "/** 0011 1000                     bra.w   %a0 */",
3760                      op[0]);
3761             }
3762           SYNTAX("bra.w %a0");
3763 #line 785 "rx-decode.opc"
3764           ID(branch); DC(pc + IMMex(2));
3765
3766         }
3767       break;
3768     case 0x39:
3769         {
3770           /** 0011 1001                 bsr.w   %a0 */
3771           if (trace)
3772             {
3773               printf ("\033[33m%s\033[0m  %02x\n",
3774                      "/** 0011 1001                     bsr.w   %a0 */",
3775                      op[0]);
3776             }
3777           SYNTAX("bsr.w %a0");
3778 #line 801 "rx-decode.opc"
3779           ID(jsr); DC(pc + IMMex(2));
3780
3781         }
3782       break;
3783     case 0x3a:
3784     case 0x3b:
3785         {
3786           /** 0011 101c                 b%1.w   %a0 */
3787 #line 775 "rx-decode.opc"
3788           int c AU = op[0] & 0x01;
3789           if (trace)
3790             {
3791               printf ("\033[33m%s\033[0m  %02x\n",
3792                      "/** 0011 101c                     b%1.w   %a0 */",
3793                      op[0]);
3794               printf ("  c = 0x%x\n", c);
3795             }
3796           SYNTAX("b%1.w %a0");
3797 #line 775 "rx-decode.opc"
3798           ID(branch); Scc(c); DC(pc + IMMex (2));
3799
3800
3801         }
3802       break;
3803     case 0x3c:
3804         GETBYTE ();
3805         switch (op[1] & 0x00)
3806         {
3807           case 0x00:
3808             op_semantics_20:
3809               {
3810                 /** 0011 11sz d dst sppp                mov%s   #%1, %0 */
3811 #line 311 "rx-decode.opc"
3812                 int sz AU = op[0] & 0x03;
3813 #line 311 "rx-decode.opc"
3814                 int d AU = (op[1] >> 7) & 0x01;
3815 #line 311 "rx-decode.opc"
3816                 int dst AU = (op[1] >> 4) & 0x07;
3817 #line 311 "rx-decode.opc"
3818                 int sppp AU = op[1] & 0x0f;
3819                 if (trace)
3820                   {
3821                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3822                            "/** 0011 11sz d dst sppp            mov%s   #%1, %0 */",
3823                            op[0], op[1]);
3824                     printf ("  sz = 0x%x,", sz);
3825                     printf ("  d = 0x%x,", d);
3826                     printf ("  dst = 0x%x,", dst);
3827                     printf ("  sppp = 0x%x\n", sppp);
3828                   }
3829                 SYNTAX("mov%s   #%1, %0");
3830 #line 311 "rx-decode.opc"
3831                 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3832
3833               }
3834             break;
3835         }
3836       break;
3837     case 0x3d:
3838         GETBYTE ();
3839         switch (op[1] & 0x00)
3840         {
3841           case 0x00:
3842             goto op_semantics_20;
3843             break;
3844         }
3845       break;
3846     case 0x3e:
3847         GETBYTE ();
3848         switch (op[1] & 0x00)
3849         {
3850           case 0x00:
3851             goto op_semantics_20;
3852             break;
3853         }
3854       break;
3855     case 0x3f:
3856         GETBYTE ();
3857         switch (op[1] & 0x00)
3858         {
3859           case 0x00:
3860               {
3861                 /** 0011 1111 rega regb         rtsd    #%1, %2-%0 */
3862 #line 408 "rx-decode.opc"
3863                 int rega AU = (op[1] >> 4) & 0x0f;
3864 #line 408 "rx-decode.opc"
3865                 int regb AU = op[1] & 0x0f;
3866                 if (trace)
3867                   {
3868                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3869                            "/** 0011 1111 rega regb             rtsd    #%1, %2-%0 */",
3870                            op[0], op[1]);
3871                     printf ("  rega = 0x%x,", rega);
3872                     printf ("  regb = 0x%x\n", regb);
3873                   }
3874                 SYNTAX("rtsd    #%1, %2-%0");
3875 #line 408 "rx-decode.opc"
3876                 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3877
3878               /*----------------------------------------------------------------------*/
3879               /* AND                                                                    */
3880
3881               }
3882             break;
3883         }
3884       break;
3885     case 0x40:
3886         GETBYTE ();
3887         switch (op[1] & 0x00)
3888         {
3889           case 0x00:
3890             op_semantics_21:
3891               {
3892                 /** 0100 00ss rsrc rdst                 sub     %2%S2, %1 */
3893 #line 543 "rx-decode.opc"
3894                 int ss AU = op[0] & 0x03;
3895 #line 543 "rx-decode.opc"
3896                 int rsrc AU = (op[1] >> 4) & 0x0f;
3897 #line 543 "rx-decode.opc"
3898                 int rdst AU = op[1] & 0x0f;
3899                 if (trace)
3900                   {
3901                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3902                            "/** 0100 00ss rsrc rdst                     sub     %2%S2, %1 */",
3903                            op[0], op[1]);
3904                     printf ("  ss = 0x%x,", ss);
3905                     printf ("  rsrc = 0x%x,", rsrc);
3906                     printf ("  rdst = 0x%x\n", rdst);
3907                   }
3908                 SYNTAX("sub     %2%S2, %1");
3909 #line 543 "rx-decode.opc"
3910                 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3911
3912               }
3913             break;
3914         }
3915       break;
3916     case 0x41:
3917         GETBYTE ();
3918         switch (op[1] & 0x00)
3919         {
3920           case 0x00:
3921             goto op_semantics_21;
3922             break;
3923         }
3924       break;
3925     case 0x42:
3926         GETBYTE ();
3927         switch (op[1] & 0x00)
3928         {
3929           case 0x00:
3930             goto op_semantics_21;
3931             break;
3932         }
3933       break;
3934     case 0x43:
3935         GETBYTE ();
3936         switch (op[1] & 0x00)
3937         {
3938           case 0x00:
3939             goto op_semantics_21;
3940             break;
3941         }
3942       break;
3943     case 0x44:
3944         GETBYTE ();
3945         switch (op[1] & 0x00)
3946         {
3947           case 0x00:
3948             op_semantics_22:
3949               {
3950                 /** 0100 01ss rsrc rdst         cmp     %2%S2, %1 */
3951 #line 531 "rx-decode.opc"
3952                 int ss AU = op[0] & 0x03;
3953 #line 531 "rx-decode.opc"
3954                 int rsrc AU = (op[1] >> 4) & 0x0f;
3955 #line 531 "rx-decode.opc"
3956                 int rdst AU = op[1] & 0x0f;
3957                 if (trace)
3958                   {
3959                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3960                            "/** 0100 01ss rsrc rdst             cmp     %2%S2, %1 */",
3961                            op[0], op[1]);
3962                     printf ("  ss = 0x%x,", ss);
3963                     printf ("  rsrc = 0x%x,", rsrc);
3964                     printf ("  rdst = 0x%x\n", rdst);
3965                   }
3966                 SYNTAX("cmp     %2%S2, %1");
3967 #line 531 "rx-decode.opc"
3968                 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3969
3970               }
3971             break;
3972         }
3973       break;
3974     case 0x45:
3975         GETBYTE ();
3976         switch (op[1] & 0x00)
3977         {
3978           case 0x00:
3979             goto op_semantics_22;
3980             break;
3981         }
3982       break;
3983     case 0x46:
3984         GETBYTE ();
3985         switch (op[1] & 0x00)
3986         {
3987           case 0x00:
3988             goto op_semantics_22;
3989             break;
3990         }
3991       break;
3992     case 0x47:
3993         GETBYTE ();
3994         switch (op[1] & 0x00)
3995         {
3996           case 0x00:
3997             goto op_semantics_22;
3998             break;
3999         }
4000       break;
4001     case 0x48:
4002         GETBYTE ();
4003         switch (op[1] & 0x00)
4004         {
4005           case 0x00:
4006             op_semantics_23:
4007               {
4008                 /** 0100 10ss rsrc rdst                 add     %1%S1, %0 */
4009 #line 507 "rx-decode.opc"
4010                 int ss AU = op[0] & 0x03;
4011 #line 507 "rx-decode.opc"
4012                 int rsrc AU = (op[1] >> 4) & 0x0f;
4013 #line 507 "rx-decode.opc"
4014                 int rdst AU = op[1] & 0x0f;
4015                 if (trace)
4016                   {
4017                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4018                            "/** 0100 10ss rsrc rdst                     add     %1%S1, %0 */",
4019                            op[0], op[1]);
4020                     printf ("  ss = 0x%x,", ss);
4021                     printf ("  rsrc = 0x%x,", rsrc);
4022                     printf ("  rdst = 0x%x\n", rdst);
4023                   }
4024                 SYNTAX("add     %1%S1, %0");
4025 #line 507 "rx-decode.opc"
4026                 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
4027
4028               }
4029             break;
4030         }
4031       break;
4032     case 0x49:
4033         GETBYTE ();
4034         switch (op[1] & 0x00)
4035         {
4036           case 0x00:
4037             goto op_semantics_23;
4038             break;
4039         }
4040       break;
4041     case 0x4a:
4042         GETBYTE ();
4043         switch (op[1] & 0x00)
4044         {
4045           case 0x00:
4046             goto op_semantics_23;
4047             break;
4048         }
4049       break;
4050     case 0x4b:
4051         GETBYTE ();
4052         switch (op[1] & 0x00)
4053         {
4054           case 0x00:
4055             goto op_semantics_23;
4056             break;
4057         }
4058       break;
4059     case 0x4c:
4060         GETBYTE ();
4061         switch (op[1] & 0x00)
4062         {
4063           case 0x00:
4064             op_semantics_24:
4065               {
4066                 /** 0100 11ss rsrc rdst                 mul     %1%S1, %0 */
4067 #line 650 "rx-decode.opc"
4068                 int ss AU = op[0] & 0x03;
4069 #line 650 "rx-decode.opc"
4070                 int rsrc AU = (op[1] >> 4) & 0x0f;
4071 #line 650 "rx-decode.opc"
4072                 int rdst AU = op[1] & 0x0f;
4073                 if (trace)
4074                   {
4075                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4076                            "/** 0100 11ss rsrc rdst                     mul     %1%S1, %0 */",
4077                            op[0], op[1]);
4078                     printf ("  ss = 0x%x,", ss);
4079                     printf ("  rsrc = 0x%x,", rsrc);
4080                     printf ("  rdst = 0x%x\n", rdst);
4081                   }
4082                 SYNTAX("mul     %1%S1, %0");
4083 #line 650 "rx-decode.opc"
4084                 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
4085
4086               }
4087             break;
4088         }
4089       break;
4090     case 0x4d:
4091         GETBYTE ();
4092         switch (op[1] & 0x00)
4093         {
4094           case 0x00:
4095             goto op_semantics_24;
4096             break;
4097         }
4098       break;
4099     case 0x4e:
4100         GETBYTE ();
4101         switch (op[1] & 0x00)
4102         {
4103           case 0x00:
4104             goto op_semantics_24;
4105             break;
4106         }
4107       break;
4108     case 0x4f:
4109         GETBYTE ();
4110         switch (op[1] & 0x00)
4111         {
4112           case 0x00:
4113             goto op_semantics_24;
4114             break;
4115         }
4116       break;
4117     case 0x50:
4118         GETBYTE ();
4119         switch (op[1] & 0x00)
4120         {
4121           case 0x00:
4122             op_semantics_25:
4123               {
4124                 /** 0101 00ss rsrc rdst                 and     %1%S1, %0 */
4125 #line 420 "rx-decode.opc"
4126                 int ss AU = op[0] & 0x03;
4127 #line 420 "rx-decode.opc"
4128                 int rsrc AU = (op[1] >> 4) & 0x0f;
4129 #line 420 "rx-decode.opc"
4130                 int rdst AU = op[1] & 0x0f;
4131                 if (trace)
4132                   {
4133                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4134                            "/** 0101 00ss rsrc rdst                     and     %1%S1, %0 */",
4135                            op[0], op[1]);
4136                     printf ("  ss = 0x%x,", ss);
4137                     printf ("  rsrc = 0x%x,", rsrc);
4138                     printf ("  rdst = 0x%x\n", rdst);
4139                   }
4140                 SYNTAX("and     %1%S1, %0");
4141 #line 420 "rx-decode.opc"
4142                 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
4143
4144               }
4145             break;
4146         }
4147       break;
4148     case 0x51:
4149         GETBYTE ();
4150         switch (op[1] & 0x00)
4151         {
4152           case 0x00:
4153             goto op_semantics_25;
4154             break;
4155         }
4156       break;
4157     case 0x52:
4158         GETBYTE ();
4159         switch (op[1] & 0x00)
4160         {
4161           case 0x00:
4162             goto op_semantics_25;
4163             break;
4164         }
4165       break;
4166     case 0x53:
4167         GETBYTE ();
4168         switch (op[1] & 0x00)
4169         {
4170           case 0x00:
4171             goto op_semantics_25;
4172             break;
4173         }
4174       break;
4175     case 0x54:
4176         GETBYTE ();
4177         switch (op[1] & 0x00)
4178         {
4179           case 0x00:
4180             op_semantics_26:
4181               {
4182                 /** 0101 01ss rsrc rdst                 or      %1%S1, %0 */
4183 #line 438 "rx-decode.opc"
4184                 int ss AU = op[0] & 0x03;
4185 #line 438 "rx-decode.opc"
4186                 int rsrc AU = (op[1] >> 4) & 0x0f;
4187 #line 438 "rx-decode.opc"
4188                 int rdst AU = op[1] & 0x0f;
4189                 if (trace)
4190                   {
4191                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4192                            "/** 0101 01ss rsrc rdst                     or      %1%S1, %0 */",
4193                            op[0], op[1]);
4194                     printf ("  ss = 0x%x,", ss);
4195                     printf ("  rsrc = 0x%x,", rsrc);
4196                     printf ("  rdst = 0x%x\n", rdst);
4197                   }
4198                 SYNTAX("or      %1%S1, %0");
4199 #line 438 "rx-decode.opc"
4200                 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4201
4202               }
4203             break;
4204         }
4205       break;
4206     case 0x55:
4207         GETBYTE ();
4208         switch (op[1] & 0x00)
4209         {
4210           case 0x00:
4211             goto op_semantics_26;
4212             break;
4213         }
4214       break;
4215     case 0x56:
4216         GETBYTE ();
4217         switch (op[1] & 0x00)
4218         {
4219           case 0x00:
4220             goto op_semantics_26;
4221             break;
4222         }
4223       break;
4224     case 0x57:
4225         GETBYTE ();
4226         switch (op[1] & 0x00)
4227         {
4228           case 0x00:
4229             goto op_semantics_26;
4230             break;
4231         }
4232       break;
4233     case 0x58:
4234         GETBYTE ();
4235         switch (op[1] & 0x00)
4236         {
4237           case 0x00:
4238             op_semantics_27:
4239               {
4240                 /** 0101 1 s ss rsrc rdst       movu%s  %1, %0 */
4241 #line 359 "rx-decode.opc"
4242                 int s AU = (op[0] >> 2) & 0x01;
4243 #line 359 "rx-decode.opc"
4244                 int ss AU = op[0] & 0x03;
4245 #line 359 "rx-decode.opc"
4246                 int rsrc AU = (op[1] >> 4) & 0x0f;
4247 #line 359 "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                            "/** 0101 1 s ss rsrc rdst   movu%s  %1, %0 */",
4253                            op[0], op[1]);
4254                     printf ("  s = 0x%x,", s);
4255                     printf ("  ss = 0x%x,", ss);
4256                     printf ("  rsrc = 0x%x,", rsrc);
4257                     printf ("  rdst = 0x%x\n", rdst);
4258                   }
4259                 SYNTAX("movu%s  %1, %0");
4260 #line 359 "rx-decode.opc"
4261                 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
4262
4263               }
4264             break;
4265         }
4266       break;
4267     case 0x59:
4268         GETBYTE ();
4269         switch (op[1] & 0x00)
4270         {
4271           case 0x00:
4272             goto op_semantics_27;
4273             break;
4274         }
4275       break;
4276     case 0x5a:
4277         GETBYTE ();
4278         switch (op[1] & 0x00)
4279         {
4280           case 0x00:
4281             goto op_semantics_27;
4282             break;
4283         }
4284       break;
4285     case 0x5b:
4286         GETBYTE ();
4287         switch (op[1] & 0x00)
4288         {
4289           case 0x00:
4290             goto op_semantics_27;
4291             break;
4292         }
4293       break;
4294     case 0x5c:
4295         GETBYTE ();
4296         switch (op[1] & 0x00)
4297         {
4298           case 0x00:
4299             goto op_semantics_27;
4300             break;
4301         }
4302       break;
4303     case 0x5d:
4304         GETBYTE ();
4305         switch (op[1] & 0x00)
4306         {
4307           case 0x00:
4308             goto op_semantics_27;
4309             break;
4310         }
4311       break;
4312     case 0x5e:
4313         GETBYTE ();
4314         switch (op[1] & 0x00)
4315         {
4316           case 0x00:
4317             goto op_semantics_27;
4318             break;
4319         }
4320       break;
4321     case 0x5f:
4322         GETBYTE ();
4323         switch (op[1] & 0x00)
4324         {
4325           case 0x00:
4326             goto op_semantics_27;
4327             break;
4328         }
4329       break;
4330     case 0x60:
4331         GETBYTE ();
4332         switch (op[1] & 0x00)
4333         {
4334           case 0x00:
4335               {
4336                 /** 0110 0000 immm rdst                 sub     #%2, %0 */
4337 #line 540 "rx-decode.opc"
4338                 int immm AU = (op[1] >> 4) & 0x0f;
4339 #line 540 "rx-decode.opc"
4340                 int rdst AU = op[1] & 0x0f;
4341                 if (trace)
4342                   {
4343                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4344                            "/** 0110 0000 immm rdst                     sub     #%2, %0 */",
4345                            op[0], op[1]);
4346                     printf ("  immm = 0x%x,", immm);
4347                     printf ("  rdst = 0x%x\n", rdst);
4348                   }
4349                 SYNTAX("sub     #%2, %0");
4350 #line 540 "rx-decode.opc"
4351                 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4352
4353               }
4354             break;
4355         }
4356       break;
4357     case 0x61:
4358         GETBYTE ();
4359         switch (op[1] & 0x00)
4360         {
4361           case 0x00:
4362               {
4363                 /** 0110 0001 immm rdst                 cmp     #%2, %1 */
4364 #line 522 "rx-decode.opc"
4365                 int immm AU = (op[1] >> 4) & 0x0f;
4366 #line 522 "rx-decode.opc"
4367                 int rdst AU = op[1] & 0x0f;
4368                 if (trace)
4369                   {
4370                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4371                            "/** 0110 0001 immm rdst                     cmp     #%2, %1 */",
4372                            op[0], op[1]);
4373                     printf ("  immm = 0x%x,", immm);
4374                     printf ("  rdst = 0x%x\n", rdst);
4375                   }
4376                 SYNTAX("cmp     #%2, %1");
4377 #line 522 "rx-decode.opc"
4378                 ID(sub); S2C(immm); SR(rdst); F_OSZC;
4379
4380               }
4381             break;
4382         }
4383       break;
4384     case 0x62:
4385         GETBYTE ();
4386         switch (op[1] & 0x00)
4387         {
4388           case 0x00:
4389               {
4390                 /** 0110 0010 immm rdst                 add     #%1, %0 */
4391 #line 504 "rx-decode.opc"
4392                 int immm AU = (op[1] >> 4) & 0x0f;
4393 #line 504 "rx-decode.opc"
4394                 int rdst AU = op[1] & 0x0f;
4395                 if (trace)
4396                   {
4397                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4398                            "/** 0110 0010 immm rdst                     add     #%1, %0 */",
4399                            op[0], op[1]);
4400                     printf ("  immm = 0x%x,", immm);
4401                     printf ("  rdst = 0x%x\n", rdst);
4402                   }
4403                 SYNTAX("add     #%1, %0");
4404 #line 504 "rx-decode.opc"
4405                 ID(add); SC(immm); DR(rdst); F_OSZC;
4406
4407               }
4408             break;
4409         }
4410       break;
4411     case 0x63:
4412         GETBYTE ();
4413         switch (op[1] & 0x00)
4414         {
4415           case 0x00:
4416               {
4417                 /** 0110 0011 immm rdst                 mul     #%1, %0 */
4418 #line 616 "rx-decode.opc"
4419                 int immm AU = (op[1] >> 4) & 0x0f;
4420 #line 616 "rx-decode.opc"
4421                 int rdst AU = op[1] & 0x0f;
4422                 if (trace)
4423                   {
4424                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4425                            "/** 0110 0011 immm rdst                     mul     #%1, %0 */",
4426                            op[0], op[1]);
4427                     printf ("  immm = 0x%x,", immm);
4428                     printf ("  rdst = 0x%x\n", rdst);
4429                   }
4430                 SYNTAX("mul     #%1, %0");
4431 #line 616 "rx-decode.opc"
4432                 if (immm == 1 && rdst == 0)
4433                   {
4434                     ID(nop2);
4435                     SYNTAX ("nop\t; mul\t#1, r0");
4436                   }
4437                 else
4438                   {
4439                     ID(mul);
4440                   }
4441                 DR(rdst); SC(immm); F_____;
4442
4443               }
4444             break;
4445         }
4446       break;
4447     case 0x64:
4448         GETBYTE ();
4449         switch (op[1] & 0x00)
4450         {
4451           case 0x00:
4452               {
4453                 /** 0110 0100 immm rdst                 and     #%1, %0 */
4454 #line 414 "rx-decode.opc"
4455                 int immm AU = (op[1] >> 4) & 0x0f;
4456 #line 414 "rx-decode.opc"
4457                 int rdst AU = op[1] & 0x0f;
4458                 if (trace)
4459                   {
4460                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4461                            "/** 0110 0100 immm rdst                     and     #%1, %0 */",
4462                            op[0], op[1]);
4463                     printf ("  immm = 0x%x,", immm);
4464                     printf ("  rdst = 0x%x\n", rdst);
4465                   }
4466                 SYNTAX("and     #%1, %0");
4467 #line 414 "rx-decode.opc"
4468                 ID(and); SC(immm); DR(rdst); F__SZ_;
4469
4470               }
4471             break;
4472         }
4473       break;
4474     case 0x65:
4475         GETBYTE ();
4476         switch (op[1] & 0x00)
4477         {
4478           case 0x00:
4479               {
4480                 /** 0110 0101 immm rdst                 or      #%1, %0 */
4481 #line 432 "rx-decode.opc"
4482                 int immm AU = (op[1] >> 4) & 0x0f;
4483 #line 432 "rx-decode.opc"
4484                 int rdst AU = op[1] & 0x0f;
4485                 if (trace)
4486                   {
4487                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4488                            "/** 0110 0101 immm rdst                     or      #%1, %0 */",
4489                            op[0], op[1]);
4490                     printf ("  immm = 0x%x,", immm);
4491                     printf ("  rdst = 0x%x\n", rdst);
4492                   }
4493                 SYNTAX("or      #%1, %0");
4494 #line 432 "rx-decode.opc"
4495                 ID(or); SC(immm); DR(rdst); F__SZ_;
4496
4497               }
4498             break;
4499         }
4500       break;
4501     case 0x66:
4502         GETBYTE ();
4503         switch (op[1] & 0x00)
4504         {
4505           case 0x00:
4506               {
4507                 /** 0110 0110 immm rdst         mov%s   #%1, %0 */
4508 #line 308 "rx-decode.opc"
4509                 int immm AU = (op[1] >> 4) & 0x0f;
4510 #line 308 "rx-decode.opc"
4511                 int rdst AU = op[1] & 0x0f;
4512                 if (trace)
4513                   {
4514                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4515                            "/** 0110 0110 immm rdst             mov%s   #%1, %0 */",
4516                            op[0], op[1]);
4517                     printf ("  immm = 0x%x,", immm);
4518                     printf ("  rdst = 0x%x\n", rdst);
4519                   }
4520                 SYNTAX("mov%s   #%1, %0");
4521 #line 308 "rx-decode.opc"
4522                 ID(mov); DR(rdst); SC(immm); F_____;
4523
4524               }
4525             break;
4526         }
4527       break;
4528     case 0x67:
4529         {
4530           /** 0110 0111                 rtsd    #%1 */
4531           if (trace)
4532             {
4533               printf ("\033[33m%s\033[0m  %02x\n",
4534                      "/** 0110 0111                     rtsd    #%1 */",
4535                      op[0]);
4536             }
4537           SYNTAX("rtsd  #%1");
4538 #line 405 "rx-decode.opc"
4539           ID(rtsd); SC(IMM(1) * 4);
4540
4541         }
4542       break;
4543     case 0x68:
4544         GETBYTE ();
4545         switch (op[1] & 0x00)
4546         {
4547           case 0x00:
4548             op_semantics_28:
4549               {
4550                 /** 0110 100i mmmm rdst                 shlr    #%2, %0 */
4551 #line 730 "rx-decode.opc"
4552                 int i AU = op[0] & 0x01;
4553 #line 730 "rx-decode.opc"
4554                 int mmmm AU = (op[1] >> 4) & 0x0f;
4555 #line 730 "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                            "/** 0110 100i mmmm rdst                     shlr    #%2, %0 */",
4561                            op[0], op[1]);
4562                     printf ("  i = 0x%x,", i);
4563                     printf ("  mmmm = 0x%x,", mmmm);
4564                     printf ("  rdst = 0x%x\n", rdst);
4565                   }
4566                 SYNTAX("shlr    #%2, %0");
4567 #line 730 "rx-decode.opc"
4568                 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4569
4570               }
4571             break;
4572         }
4573       break;
4574     case 0x69:
4575         GETBYTE ();
4576         switch (op[1] & 0x00)
4577         {
4578           case 0x00:
4579             goto op_semantics_28;
4580             break;
4581         }
4582       break;
4583     case 0x6a:
4584         GETBYTE ();
4585         switch (op[1] & 0x00)
4586         {
4587           case 0x00:
4588             op_semantics_29:
4589               {
4590                 /** 0110 101i mmmm rdst                 shar    #%2, %0 */
4591 #line 720 "rx-decode.opc"
4592                 int i AU = op[0] & 0x01;
4593 #line 720 "rx-decode.opc"
4594                 int mmmm AU = (op[1] >> 4) & 0x0f;
4595 #line 720 "rx-decode.opc"
4596                 int rdst AU = op[1] & 0x0f;
4597                 if (trace)
4598                   {
4599                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4600                            "/** 0110 101i mmmm rdst                     shar    #%2, %0 */",
4601                            op[0], op[1]);
4602                     printf ("  i = 0x%x,", i);
4603                     printf ("  mmmm = 0x%x,", mmmm);
4604                     printf ("  rdst = 0x%x\n", rdst);
4605                   }
4606                 SYNTAX("shar    #%2, %0");
4607 #line 720 "rx-decode.opc"
4608                 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4609
4610               }
4611             break;
4612         }
4613       break;
4614     case 0x6b:
4615         GETBYTE ();
4616         switch (op[1] & 0x00)
4617         {
4618           case 0x00:
4619             goto op_semantics_29;
4620             break;
4621         }
4622       break;
4623     case 0x6c:
4624         GETBYTE ();
4625         switch (op[1] & 0x00)
4626         {
4627           case 0x00:
4628             op_semantics_30:
4629               {
4630                 /** 0110 110i mmmm rdst                 shll    #%2, %0 */
4631 #line 710 "rx-decode.opc"
4632                 int i AU = op[0] & 0x01;
4633 #line 710 "rx-decode.opc"
4634                 int mmmm AU = (op[1] >> 4) & 0x0f;
4635 #line 710 "rx-decode.opc"
4636                 int rdst AU = op[1] & 0x0f;
4637                 if (trace)
4638                   {
4639                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4640                            "/** 0110 110i mmmm rdst                     shll    #%2, %0 */",
4641                            op[0], op[1]);
4642                     printf ("  i = 0x%x,", i);
4643                     printf ("  mmmm = 0x%x,", mmmm);
4644                     printf ("  rdst = 0x%x\n", rdst);
4645                   }
4646                 SYNTAX("shll    #%2, %0");
4647 #line 710 "rx-decode.opc"
4648                 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4649
4650               }
4651             break;
4652         }
4653       break;
4654     case 0x6d:
4655         GETBYTE ();
4656         switch (op[1] & 0x00)
4657         {
4658           case 0x00:
4659             goto op_semantics_30;
4660             break;
4661         }
4662       break;
4663     case 0x6e:
4664         GETBYTE ();
4665         switch (op[1] & 0x00)
4666         {
4667           case 0x00:
4668               {
4669                 /** 0110 1110 dsta dstb         pushm   %1-%2 */
4670 #line 372 "rx-decode.opc"
4671                 int dsta AU = (op[1] >> 4) & 0x0f;
4672 #line 372 "rx-decode.opc"
4673                 int dstb AU = op[1] & 0x0f;
4674                 if (trace)
4675                   {
4676                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4677                            "/** 0110 1110 dsta dstb             pushm   %1-%2 */",
4678                            op[0], op[1]);
4679                     printf ("  dsta = 0x%x,", dsta);
4680                     printf ("  dstb = 0x%x\n", dstb);
4681                   }
4682                 SYNTAX("pushm   %1-%2");
4683 #line 372 "rx-decode.opc"
4684                 ID(pushm); SR(dsta); S2R(dstb); F_____;
4685
4686               }
4687             break;
4688         }
4689       break;
4690     case 0x6f:
4691         GETBYTE ();
4692         switch (op[1] & 0x00)
4693         {
4694           case 0x00:
4695               {
4696                 /** 0110 1111 dsta dstb         popm    %1-%2 */
4697 #line 369 "rx-decode.opc"
4698                 int dsta AU = (op[1] >> 4) & 0x0f;
4699 #line 369 "rx-decode.opc"
4700                 int dstb AU = op[1] & 0x0f;
4701                 if (trace)
4702                   {
4703                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4704                            "/** 0110 1111 dsta dstb             popm    %1-%2 */",
4705                            op[0], op[1]);
4706                     printf ("  dsta = 0x%x,", dsta);
4707                     printf ("  dstb = 0x%x\n", dstb);
4708                   }
4709                 SYNTAX("popm    %1-%2");
4710 #line 369 "rx-decode.opc"
4711                 ID(popm); SR(dsta); S2R(dstb); F_____;
4712
4713               }
4714             break;
4715         }
4716       break;
4717     case 0x70:
4718         GETBYTE ();
4719         switch (op[1] & 0x00)
4720         {
4721           case 0x00:
4722             op_semantics_31:
4723               {
4724                 /** 0111 00im rsrc rdst                 add     #%1, %2, %0 */
4725 #line 513 "rx-decode.opc"
4726                 int im AU = op[0] & 0x03;
4727 #line 513 "rx-decode.opc"
4728                 int rsrc AU = (op[1] >> 4) & 0x0f;
4729 #line 513 "rx-decode.opc"
4730                 int rdst AU = op[1] & 0x0f;
4731                 if (trace)
4732                   {
4733                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4734                            "/** 0111 00im rsrc rdst                     add     #%1, %2, %0 */",
4735                            op[0], op[1]);
4736                     printf ("  im = 0x%x,", im);
4737                     printf ("  rsrc = 0x%x,", rsrc);
4738                     printf ("  rdst = 0x%x\n", rdst);
4739                   }
4740                 SYNTAX("add     #%1, %2, %0");
4741 #line 513 "rx-decode.opc"
4742                 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4743
4744               }
4745             break;
4746         }
4747       break;
4748     case 0x71:
4749         GETBYTE ();
4750         switch (op[1] & 0x00)
4751         {
4752           case 0x00:
4753             goto op_semantics_31;
4754             break;
4755         }
4756       break;
4757     case 0x72:
4758         GETBYTE ();
4759         switch (op[1] & 0x00)
4760         {
4761           case 0x00:
4762             goto op_semantics_31;
4763             break;
4764         }
4765       break;
4766     case 0x73:
4767         GETBYTE ();
4768         switch (op[1] & 0x00)
4769         {
4770           case 0x00:
4771             goto op_semantics_31;
4772             break;
4773         }
4774       break;
4775     case 0x74:
4776         GETBYTE ();
4777         switch (op[1] & 0xf0)
4778         {
4779           case 0x00:
4780             op_semantics_32:
4781               {
4782                 /** 0111 01im 0000 rsrc         cmp     #%2, %1%S1 */
4783 #line 525 "rx-decode.opc"
4784                 int im AU = op[0] & 0x03;
4785 #line 525 "rx-decode.opc"
4786                 int rsrc AU = op[1] & 0x0f;
4787                 if (trace)
4788                   {
4789                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4790                            "/** 0111 01im 0000 rsrc             cmp     #%2, %1%S1 */",
4791                            op[0], op[1]);
4792                     printf ("  im = 0x%x,", im);
4793                     printf ("  rsrc = 0x%x\n", rsrc);
4794                   }
4795                 SYNTAX("cmp     #%2, %1%S1");
4796 #line 525 "rx-decode.opc"
4797                 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4798
4799               }
4800             break;
4801           case 0x10:
4802             op_semantics_33:
4803               {
4804                 /** 0111 01im 0001rdst                  mul     #%1, %0 */
4805 #line 628 "rx-decode.opc"
4806                 int im AU = op[0] & 0x03;
4807 #line 628 "rx-decode.opc"
4808                 int rdst AU = op[1] & 0x0f;
4809                 if (trace)
4810                   {
4811                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4812                            "/** 0111 01im 0001rdst                      mul     #%1, %0 */",
4813                            op[0], op[1]);
4814                     printf ("  im = 0x%x,", im);
4815                     printf ("  rdst = 0x%x\n", rdst);
4816                   }
4817                 SYNTAX("mul     #%1, %0");
4818 #line 628 "rx-decode.opc"
4819                 int val = IMMex(im);
4820                 if (val == 1 && rdst == 0)
4821                   {
4822                     SYNTAX("nop\t; mul\t#1, r0");
4823                     switch (im)
4824                 {
4825                 case 2: ID(nop4); break;
4826                 case 3: ID(nop5); break;
4827                 case 0: ID(nop6); break;
4828                 default:
4829                   ID(mul);
4830                   SYNTAX("mul   #%1, %0");
4831                   break;
4832                 }
4833                   }
4834                 else
4835                   {
4836                     ID(mul);
4837                   }
4838                 DR(rdst); SC(val); F_____;
4839
4840               }
4841             break;
4842           case 0x20:
4843             op_semantics_34:
4844               {
4845                 /** 0111 01im 0010 rdst                 and     #%1, %0 */
4846 #line 417 "rx-decode.opc"
4847                 int im AU = op[0] & 0x03;
4848 #line 417 "rx-decode.opc"
4849                 int rdst AU = op[1] & 0x0f;
4850                 if (trace)
4851                   {
4852                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4853                            "/** 0111 01im 0010 rdst                     and     #%1, %0 */",
4854                            op[0], op[1]);
4855                     printf ("  im = 0x%x,", im);
4856                     printf ("  rdst = 0x%x\n", rdst);
4857                   }
4858                 SYNTAX("and     #%1, %0");
4859 #line 417 "rx-decode.opc"
4860                 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4861
4862               }
4863             break;
4864           case 0x30:
4865             op_semantics_35:
4866               {
4867                 /** 0111 01im 0011 rdst                 or      #%1, %0 */
4868 #line 435 "rx-decode.opc"
4869                 int im AU = op[0] & 0x03;
4870 #line 435 "rx-decode.opc"
4871                 int rdst AU = op[1] & 0x0f;
4872                 if (trace)
4873                   {
4874                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4875                            "/** 0111 01im 0011 rdst                     or      #%1, %0 */",
4876                            op[0], op[1]);
4877                     printf ("  im = 0x%x,", im);
4878                     printf ("  rdst = 0x%x\n", rdst);
4879                   }
4880                 SYNTAX("or      #%1, %0");
4881 #line 435 "rx-decode.opc"
4882                 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4883
4884               }
4885             break;
4886           default: UNSUPPORTED(); break;
4887         }
4888       break;
4889     case 0x75:
4890         GETBYTE ();
4891         switch (op[1] & 0xff)
4892         {
4893           case 0x00:
4894           case 0x01:
4895           case 0x02:
4896           case 0x03:
4897           case 0x04:
4898           case 0x05:
4899           case 0x06:
4900           case 0x07:
4901           case 0x08:
4902           case 0x09:
4903           case 0x0a:
4904           case 0x0b:
4905           case 0x0c:
4906           case 0x0d:
4907           case 0x0e:
4908           case 0x0f:
4909             goto op_semantics_32;
4910             break;
4911           case 0x10:
4912           case 0x11:
4913           case 0x12:
4914           case 0x13:
4915           case 0x14:
4916           case 0x15:
4917           case 0x16:
4918           case 0x17:
4919           case 0x18:
4920           case 0x19:
4921           case 0x1a:
4922           case 0x1b:
4923           case 0x1c:
4924           case 0x1d:
4925           case 0x1e:
4926           case 0x1f:
4927             goto op_semantics_33;
4928             break;
4929           case 0x20:
4930           case 0x21:
4931           case 0x22:
4932           case 0x23:
4933           case 0x24:
4934           case 0x25:
4935           case 0x26:
4936           case 0x27:
4937           case 0x28:
4938           case 0x29:
4939           case 0x2a:
4940           case 0x2b:
4941           case 0x2c:
4942           case 0x2d:
4943           case 0x2e:
4944           case 0x2f:
4945             goto op_semantics_34;
4946             break;
4947           case 0x30:
4948           case 0x31:
4949           case 0x32:
4950           case 0x33:
4951           case 0x34:
4952           case 0x35:
4953           case 0x36:
4954           case 0x37:
4955           case 0x38:
4956           case 0x39:
4957           case 0x3a:
4958           case 0x3b:
4959           case 0x3c:
4960           case 0x3d:
4961           case 0x3e:
4962           case 0x3f:
4963             goto op_semantics_35;
4964             break;
4965           case 0x40:
4966           case 0x41:
4967           case 0x42:
4968           case 0x43:
4969           case 0x44:
4970           case 0x45:
4971           case 0x46:
4972           case 0x47:
4973           case 0x48:
4974           case 0x49:
4975           case 0x4a:
4976           case 0x4b:
4977           case 0x4c:
4978           case 0x4d:
4979           case 0x4e:
4980           case 0x4f:
4981               {
4982                 /** 0111 0101 0100 rdst         mov%s   #%1, %0 */
4983 #line 289 "rx-decode.opc"
4984                 int rdst AU = op[1] & 0x0f;
4985                 if (trace)
4986                   {
4987                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4988                            "/** 0111 0101 0100 rdst             mov%s   #%1, %0 */",
4989                            op[0], op[1]);
4990                     printf ("  rdst = 0x%x\n", rdst);
4991                   }
4992                 SYNTAX("mov%s   #%1, %0");
4993 #line 289 "rx-decode.opc"
4994                 ID(mov); DR(rdst); SC(IMM (1)); F_____;
4995
4996               }
4997             break;
4998           case 0x50:
4999           case 0x51:
5000           case 0x52:
5001           case 0x53:
5002           case 0x54:
5003           case 0x55:
5004           case 0x56:
5005           case 0x57:
5006           case 0x58:
5007           case 0x59:
5008           case 0x5a:
5009           case 0x5b:
5010           case 0x5c:
5011           case 0x5d:
5012           case 0x5e:
5013           case 0x5f:
5014               {
5015                 /** 0111 0101 0101 rsrc                 cmp     #%2, %1 */
5016 #line 528 "rx-decode.opc"
5017                 int rsrc AU = op[1] & 0x0f;
5018                 if (trace)
5019                   {
5020                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5021                            "/** 0111 0101 0101 rsrc                     cmp     #%2, %1 */",
5022                            op[0], op[1]);
5023                     printf ("  rsrc = 0x%x\n", rsrc);
5024                   }
5025                 SYNTAX("cmp     #%2, %1");
5026 #line 528 "rx-decode.opc"
5027                 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
5028
5029               }
5030             break;
5031           case 0x60:
5032               {
5033                 /** 0111 0101 0110 0000         int #%1 */
5034                 if (trace)
5035                   {
5036                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5037                            "/** 0111 0101 0110 0000             int #%1 */",
5038                            op[0], op[1]);
5039                   }
5040                 SYNTAX("int #%1");
5041 #line 1035 "rx-decode.opc"
5042                 ID(int); SC(IMM(1));
5043
5044               }
5045             break;
5046           case 0x70:
5047               GETBYTE ();
5048               switch (op[2] & 0xf0)
5049               {
5050                 case 0x00:
5051                     {
5052                       /** 0111 0101 0111 0000 0000 immm mvtipl  #%1 */
5053 #line 1002 "rx-decode.opc"
5054                       int immm AU = op[2] & 0x0f;
5055                       if (trace)
5056                         {
5057                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5058                                  "/** 0111 0101 0111 0000 0000 immm     mvtipl  #%1 */",
5059                                  op[0], op[1], op[2]);
5060                           printf ("  immm = 0x%x\n", immm);
5061                         }
5062                       SYNTAX("mvtipl    #%1");
5063 #line 1002 "rx-decode.opc"
5064                       ID(mvtipl); SC(immm);
5065
5066                     }
5067                   break;
5068                 default: UNSUPPORTED(); break;
5069               }
5070             break;
5071           default: UNSUPPORTED(); break;
5072         }
5073       break;
5074     case 0x76:
5075         GETBYTE ();
5076         switch (op[1] & 0xf0)
5077         {
5078           case 0x00:
5079             goto op_semantics_32;
5080             break;
5081           case 0x10:
5082             goto op_semantics_33;
5083             break;
5084           case 0x20:
5085             goto op_semantics_34;
5086             break;
5087           case 0x30:
5088             goto op_semantics_35;
5089             break;
5090           default: UNSUPPORTED(); break;
5091         }
5092       break;
5093     case 0x77:
5094         GETBYTE ();
5095         switch (op[1] & 0xf0)
5096         {
5097           case 0x00:
5098             goto op_semantics_32;
5099             break;
5100           case 0x10:
5101             goto op_semantics_33;
5102             break;
5103           case 0x20:
5104             goto op_semantics_34;
5105             break;
5106           case 0x30:
5107             goto op_semantics_35;
5108             break;
5109           default: UNSUPPORTED(); break;
5110         }
5111       break;
5112     case 0x78:
5113         GETBYTE ();
5114         switch (op[1] & 0x00)
5115         {
5116           case 0x00:
5117             op_semantics_36:
5118               {
5119                 /** 0111 100b ittt rdst                 bset    #%1, %0 */
5120 #line 947 "rx-decode.opc"
5121                 int b AU = op[0] & 0x01;
5122 #line 947 "rx-decode.opc"
5123                 int ittt AU = (op[1] >> 4) & 0x0f;
5124 #line 947 "rx-decode.opc"
5125                 int rdst AU = op[1] & 0x0f;
5126                 if (trace)
5127                   {
5128                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5129                            "/** 0111 100b ittt rdst                     bset    #%1, %0 */",
5130                            op[0], op[1]);
5131                     printf ("  b = 0x%x,", b);
5132                     printf ("  ittt = 0x%x,", ittt);
5133                     printf ("  rdst = 0x%x\n", rdst);
5134                   }
5135                 SYNTAX("bset    #%1, %0");
5136 #line 947 "rx-decode.opc"
5137                 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5138
5139
5140               }
5141             break;
5142         }
5143       break;
5144     case 0x79:
5145         GETBYTE ();
5146         switch (op[1] & 0x00)
5147         {
5148           case 0x00:
5149             goto op_semantics_36;
5150             break;
5151         }
5152       break;
5153     case 0x7a:
5154         GETBYTE ();
5155         switch (op[1] & 0x00)
5156         {
5157           case 0x00:
5158             op_semantics_37:
5159               {
5160                 /** 0111 101b ittt rdst                 bclr    #%1, %0 */
5161 #line 959 "rx-decode.opc"
5162                 int b AU = op[0] & 0x01;
5163 #line 959 "rx-decode.opc"
5164                 int ittt AU = (op[1] >> 4) & 0x0f;
5165 #line 959 "rx-decode.opc"
5166                 int rdst AU = op[1] & 0x0f;
5167                 if (trace)
5168                   {
5169                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5170                            "/** 0111 101b ittt rdst                     bclr    #%1, %0 */",
5171                            op[0], op[1]);
5172                     printf ("  b = 0x%x,", b);
5173                     printf ("  ittt = 0x%x,", ittt);
5174                     printf ("  rdst = 0x%x\n", rdst);
5175                   }
5176                 SYNTAX("bclr    #%1, %0");
5177 #line 959 "rx-decode.opc"
5178                 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5179
5180
5181               }
5182             break;
5183         }
5184       break;
5185     case 0x7b:
5186         GETBYTE ();
5187         switch (op[1] & 0x00)
5188         {
5189           case 0x00:
5190             goto op_semantics_37;
5191             break;
5192         }
5193       break;
5194     case 0x7c:
5195         GETBYTE ();
5196         switch (op[1] & 0x00)
5197         {
5198           case 0x00:
5199             op_semantics_38:
5200               {
5201                 /** 0111 110b ittt rdst                 btst    #%2, %1 */
5202 #line 971 "rx-decode.opc"
5203                 int b AU = op[0] & 0x01;
5204 #line 971 "rx-decode.opc"
5205                 int ittt AU = (op[1] >> 4) & 0x0f;
5206 #line 971 "rx-decode.opc"
5207                 int rdst AU = op[1] & 0x0f;
5208                 if (trace)
5209                   {
5210                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5211                            "/** 0111 110b ittt rdst                     btst    #%2, %1 */",
5212                            op[0], op[1]);
5213                     printf ("  b = 0x%x,", b);
5214                     printf ("  ittt = 0x%x,", ittt);
5215                     printf ("  rdst = 0x%x\n", rdst);
5216                   }
5217                 SYNTAX("btst    #%2, %1");
5218 #line 971 "rx-decode.opc"
5219                 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
5220
5221
5222               }
5223             break;
5224         }
5225       break;
5226     case 0x7d:
5227         GETBYTE ();
5228         switch (op[1] & 0x00)
5229         {
5230           case 0x00:
5231             goto op_semantics_38;
5232             break;
5233         }
5234       break;
5235     case 0x7e:
5236         GETBYTE ();
5237         switch (op[1] & 0xf0)
5238         {
5239           case 0x00:
5240               {
5241                 /** 0111 1110 0000 rdst                 not     %0 */
5242 #line 462 "rx-decode.opc"
5243                 int rdst AU = op[1] & 0x0f;
5244                 if (trace)
5245                   {
5246                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5247                            "/** 0111 1110 0000 rdst                     not     %0 */",
5248                            op[0], op[1]);
5249                     printf ("  rdst = 0x%x\n", rdst);
5250                   }
5251                 SYNTAX("not     %0");
5252 #line 462 "rx-decode.opc"
5253                 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
5254
5255               }
5256             break;
5257           case 0x10:
5258               {
5259                 /** 0111 1110 0001 rdst                 neg     %0 */
5260 #line 483 "rx-decode.opc"
5261                 int rdst AU = op[1] & 0x0f;
5262                 if (trace)
5263                   {
5264                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5265                            "/** 0111 1110 0001 rdst                     neg     %0 */",
5266                            op[0], op[1]);
5267                     printf ("  rdst = 0x%x\n", rdst);
5268                   }
5269                 SYNTAX("neg     %0");
5270 #line 483 "rx-decode.opc"
5271                 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
5272
5273               }
5274             break;
5275           case 0x20:
5276               {
5277                 /** 0111 1110 0010 rdst                 abs     %0 */
5278 #line 565 "rx-decode.opc"
5279                 int rdst AU = op[1] & 0x0f;
5280                 if (trace)
5281                   {
5282                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5283                            "/** 0111 1110 0010 rdst                     abs     %0 */",
5284                            op[0], op[1]);
5285                     printf ("  rdst = 0x%x\n", rdst);
5286                   }
5287                 SYNTAX("abs     %0");
5288 #line 565 "rx-decode.opc"
5289                 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
5290
5291               }
5292             break;
5293           case 0x30:
5294               {
5295                 /** 0111 1110 0011 rdst         sat     %0 */
5296 #line 885 "rx-decode.opc"
5297                 int rdst AU = op[1] & 0x0f;
5298                 if (trace)
5299                   {
5300                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5301                            "/** 0111 1110 0011 rdst             sat     %0 */",
5302                            op[0], op[1]);
5303                     printf ("  rdst = 0x%x\n", rdst);
5304                   }
5305                 SYNTAX("sat     %0");
5306 #line 885 "rx-decode.opc"
5307                 ID(sat); DR (rdst);
5308
5309               }
5310             break;
5311           case 0x40:
5312               {
5313                 /** 0111 1110 0100 rdst                 rorc    %0 */
5314 #line 745 "rx-decode.opc"
5315                 int rdst AU = op[1] & 0x0f;
5316                 if (trace)
5317                   {
5318                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5319                            "/** 0111 1110 0100 rdst                     rorc    %0 */",
5320                            op[0], op[1]);
5321                     printf ("  rdst = 0x%x\n", rdst);
5322                   }
5323                 SYNTAX("rorc    %0");
5324 #line 745 "rx-decode.opc"
5325                 ID(rorc); DR(rdst); F__SZC;
5326
5327               }
5328             break;
5329           case 0x50:
5330               {
5331                 /** 0111 1110 0101 rdst                 rolc    %0 */
5332 #line 742 "rx-decode.opc"
5333                 int rdst AU = op[1] & 0x0f;
5334                 if (trace)
5335                   {
5336                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5337                            "/** 0111 1110 0101 rdst                     rolc    %0 */",
5338                            op[0], op[1]);
5339                     printf ("  rdst = 0x%x\n", rdst);
5340                   }
5341                 SYNTAX("rolc    %0");
5342 #line 742 "rx-decode.opc"
5343                 ID(rolc); DR(rdst); F__SZC;
5344
5345               }
5346             break;
5347           case 0x80:
5348           case 0x90:
5349           case 0xa0:
5350               {
5351                 /** 0111 1110 10sz rsrc         push%s  %1 */
5352 #line 378 "rx-decode.opc"
5353                 int sz AU = (op[1] >> 4) & 0x03;
5354 #line 378 "rx-decode.opc"
5355                 int rsrc AU = op[1] & 0x0f;
5356                 if (trace)
5357                   {
5358                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5359                            "/** 0111 1110 10sz rsrc             push%s  %1 */",
5360                            op[0], op[1]);
5361                     printf ("  sz = 0x%x,", sz);
5362                     printf ("  rsrc = 0x%x\n", rsrc);
5363                   }
5364                 SYNTAX("push%s  %1");
5365 #line 378 "rx-decode.opc"
5366                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
5367
5368               }
5369             break;
5370           case 0xb0:
5371               {
5372                 /** 0111 1110 1011 rdst         pop     %0 */
5373 #line 375 "rx-decode.opc"
5374                 int rdst AU = op[1] & 0x0f;
5375                 if (trace)
5376                   {
5377                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5378                            "/** 0111 1110 1011 rdst             pop     %0 */",
5379                            op[0], op[1]);
5380                     printf ("  rdst = 0x%x\n", rdst);
5381                   }
5382                 SYNTAX("pop     %0");
5383 #line 375 "rx-decode.opc"
5384                 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
5385
5386               }
5387             break;
5388           case 0xc0:
5389           case 0xd0:
5390               {
5391                 /** 0111 1110 110 crsrc                 pushc   %1 */
5392 #line 1008 "rx-decode.opc"
5393                 int crsrc AU = op[1] & 0x1f;
5394                 if (trace)
5395                   {
5396                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5397                            "/** 0111 1110 110 crsrc                     pushc   %1 */",
5398                            op[0], op[1]);
5399                     printf ("  crsrc = 0x%x\n", crsrc);
5400                   }
5401                 SYNTAX("pushc   %1");
5402 #line 1008 "rx-decode.opc"
5403                 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5404
5405               }
5406             break;
5407           case 0xe0:
5408           case 0xf0:
5409               {
5410                 /** 0111 1110 111 crdst                 popc    %0 */
5411 #line 1005 "rx-decode.opc"
5412                 int crdst AU = op[1] & 0x1f;
5413                 if (trace)
5414                   {
5415                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5416                            "/** 0111 1110 111 crdst                     popc    %0 */",
5417                            op[0], op[1]);
5418                     printf ("  crdst = 0x%x\n", crdst);
5419                   }
5420                 SYNTAX("popc    %0");
5421 #line 1005 "rx-decode.opc"
5422                 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5423
5424               }
5425             break;
5426           default: UNSUPPORTED(); break;
5427         }
5428       break;
5429     case 0x7f:
5430         GETBYTE ();
5431         switch (op[1] & 0xff)
5432         {
5433           case 0x00:
5434           case 0x01:
5435           case 0x02:
5436           case 0x03:
5437           case 0x04:
5438           case 0x05:
5439           case 0x06:
5440           case 0x07:
5441           case 0x08:
5442           case 0x09:
5443           case 0x0a:
5444           case 0x0b:
5445           case 0x0c:
5446           case 0x0d:
5447           case 0x0e:
5448           case 0x0f:
5449               {
5450                 /** 0111 1111 0000 rsrc         jmp     %0 */
5451 #line 795 "rx-decode.opc"
5452                 int rsrc AU = op[1] & 0x0f;
5453                 if (trace)
5454                   {
5455                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5456                            "/** 0111 1111 0000 rsrc             jmp     %0 */",
5457                            op[0], op[1]);
5458                     printf ("  rsrc = 0x%x\n", rsrc);
5459                   }
5460                 SYNTAX("jmp     %0");
5461 #line 795 "rx-decode.opc"
5462                 ID(branch); DR(rsrc);
5463
5464               }
5465             break;
5466           case 0x10:
5467           case 0x11:
5468           case 0x12:
5469           case 0x13:
5470           case 0x14:
5471           case 0x15:
5472           case 0x16:
5473           case 0x17:
5474           case 0x18:
5475           case 0x19:
5476           case 0x1a:
5477           case 0x1b:
5478           case 0x1c:
5479           case 0x1d:
5480           case 0x1e:
5481           case 0x1f:
5482               {
5483                 /** 0111 1111 0001 rsrc         jsr     %0 */
5484 #line 798 "rx-decode.opc"
5485                 int rsrc AU = op[1] & 0x0f;
5486                 if (trace)
5487                   {
5488                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5489                            "/** 0111 1111 0001 rsrc             jsr     %0 */",
5490                            op[0], op[1]);
5491                     printf ("  rsrc = 0x%x\n", rsrc);
5492                   }
5493                 SYNTAX("jsr     %0");
5494 #line 798 "rx-decode.opc"
5495                 ID(jsr); DR(rsrc);
5496
5497               }
5498             break;
5499           case 0x40:
5500           case 0x41:
5501           case 0x42:
5502           case 0x43:
5503           case 0x44:
5504           case 0x45:
5505           case 0x46:
5506           case 0x47:
5507           case 0x48:
5508           case 0x49:
5509           case 0x4a:
5510           case 0x4b:
5511           case 0x4c:
5512           case 0x4d:
5513           case 0x4e:
5514           case 0x4f:
5515               {
5516                 /** 0111 1111 0100 rsrc         bra.l   %0 */
5517 #line 791 "rx-decode.opc"
5518                 int rsrc AU = op[1] & 0x0f;
5519                 if (trace)
5520                   {
5521                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5522                            "/** 0111 1111 0100 rsrc             bra.l   %0 */",
5523                            op[0], op[1]);
5524                     printf ("  rsrc = 0x%x\n", rsrc);
5525                   }
5526                 SYNTAX("bra.l   %0");
5527 #line 791 "rx-decode.opc"
5528                 ID(branchrel); DR(rsrc);
5529
5530
5531               }
5532             break;
5533           case 0x50:
5534           case 0x51:
5535           case 0x52:
5536           case 0x53:
5537           case 0x54:
5538           case 0x55:
5539           case 0x56:
5540           case 0x57:
5541           case 0x58:
5542           case 0x59:
5543           case 0x5a:
5544           case 0x5b:
5545           case 0x5c:
5546           case 0x5d:
5547           case 0x5e:
5548           case 0x5f:
5549               {
5550                 /** 0111 1111 0101 rsrc         bsr.l   %0 */
5551 #line 807 "rx-decode.opc"
5552                 int rsrc AU = op[1] & 0x0f;
5553                 if (trace)
5554                   {
5555                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5556                            "/** 0111 1111 0101 rsrc             bsr.l   %0 */",
5557                            op[0], op[1]);
5558                     printf ("  rsrc = 0x%x\n", rsrc);
5559                   }
5560                 SYNTAX("bsr.l   %0");
5561 #line 807 "rx-decode.opc"
5562                 ID(jsrrel); DR(rsrc);
5563
5564               }
5565             break;
5566           case 0x80:
5567           case 0x81:
5568           case 0x82:
5569               {
5570                 /** 0111 1111 1000 00sz         suntil%s */
5571 #line 831 "rx-decode.opc"
5572                 int sz AU = op[1] & 0x03;
5573                 if (trace)
5574                   {
5575                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5576                            "/** 0111 1111 1000 00sz             suntil%s */",
5577                            op[0], op[1]);
5578                     printf ("  sz = 0x%x\n", sz);
5579                   }
5580                 SYNTAX("suntil%s");
5581 #line 831 "rx-decode.opc"
5582                 ID(suntil); BWL(sz); F___ZC;
5583
5584               }
5585             break;
5586           case 0x83:
5587               {
5588                 /** 0111 1111 1000 0011         scmpu */
5589                 if (trace)
5590                   {
5591                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5592                            "/** 0111 1111 1000 0011             scmpu */",
5593                            op[0], op[1]);
5594                   }
5595                 SYNTAX("scmpu");
5596 #line 822 "rx-decode.opc"
5597                 ID(scmpu); F___ZC;
5598
5599               }
5600             break;
5601           case 0x84:
5602           case 0x85:
5603           case 0x86:
5604               {
5605                 /** 0111 1111 1000 01sz         swhile%s */
5606 #line 834 "rx-decode.opc"
5607                 int sz AU = op[1] & 0x03;
5608                 if (trace)
5609                   {
5610                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5611                            "/** 0111 1111 1000 01sz             swhile%s */",
5612                            op[0], op[1]);
5613                     printf ("  sz = 0x%x\n", sz);
5614                   }
5615                 SYNTAX("swhile%s");
5616 #line 834 "rx-decode.opc"
5617                 ID(swhile); BWL(sz); F___ZC;
5618
5619               }
5620             break;
5621           case 0x87:
5622               {
5623                 /** 0111 1111 1000 0111         smovu */
5624                 if (trace)
5625                   {
5626                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5627                            "/** 0111 1111 1000 0111             smovu */",
5628                            op[0], op[1]);
5629                   }
5630                 SYNTAX("smovu");
5631 #line 825 "rx-decode.opc"
5632                 ID(smovu);
5633
5634               }
5635             break;
5636           case 0x88:
5637           case 0x89:
5638           case 0x8a:
5639               {
5640                 /** 0111 1111 1000 10sz         sstr%s */
5641 #line 840 "rx-decode.opc"
5642                 int sz AU = op[1] & 0x03;
5643                 if (trace)
5644                   {
5645                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5646                            "/** 0111 1111 1000 10sz             sstr%s */",
5647                            op[0], op[1]);
5648                     printf ("  sz = 0x%x\n", sz);
5649                   }
5650                 SYNTAX("sstr%s");
5651 #line 840 "rx-decode.opc"
5652                 ID(sstr); BWL(sz);
5653
5654               /*----------------------------------------------------------------------*/
5655               /* RMPA                                                                   */
5656
5657               }
5658             break;
5659           case 0x8b:
5660               {
5661                 /** 0111 1111 1000 1011         smovb */
5662                 if (trace)
5663                   {
5664                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5665                            "/** 0111 1111 1000 1011             smovb */",
5666                            op[0], op[1]);
5667                   }
5668                 SYNTAX("smovb");
5669 #line 828 "rx-decode.opc"
5670                 ID(smovb);
5671
5672               }
5673             break;
5674           case 0x8c:
5675           case 0x8d:
5676           case 0x8e:
5677               {
5678                 /** 0111 1111 1000 11sz         rmpa%s */
5679 #line 846 "rx-decode.opc"
5680                 int sz AU = op[1] & 0x03;
5681                 if (trace)
5682                   {
5683                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5684                            "/** 0111 1111 1000 11sz             rmpa%s */",
5685                            op[0], op[1]);
5686                     printf ("  sz = 0x%x\n", sz);
5687                   }
5688                 SYNTAX("rmpa%s");
5689 #line 846 "rx-decode.opc"
5690                 ID(rmpa); BWL(sz); F_OS__;
5691
5692               /*----------------------------------------------------------------------*/
5693               /* HI/LO stuff                                                            */
5694
5695               }
5696             break;
5697           case 0x8f:
5698               {
5699                 /** 0111 1111 1000 1111         smovf */
5700                 if (trace)
5701                   {
5702                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5703                            "/** 0111 1111 1000 1111             smovf */",
5704                            op[0], op[1]);
5705                   }
5706                 SYNTAX("smovf");
5707 #line 837 "rx-decode.opc"
5708                 ID(smovf);
5709
5710               }
5711             break;
5712           case 0x93:
5713               {
5714                 /** 0111 1111 1001 0011         satr */
5715                 if (trace)
5716                   {
5717                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5718                            "/** 0111 1111 1001 0011             satr */",
5719                            op[0], op[1]);
5720                   }
5721                 SYNTAX("satr");
5722 #line 888 "rx-decode.opc"
5723                 ID(satr);
5724
5725               /*----------------------------------------------------------------------*/
5726               /* FLOAT                                                          */
5727
5728               }
5729             break;
5730           case 0x94:
5731               {
5732                 /** 0111 1111 1001 0100         rtfi */
5733                 if (trace)
5734                   {
5735                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5736                            "/** 0111 1111 1001 0100             rtfi */",
5737                            op[0], op[1]);
5738                   }
5739                 SYNTAX("rtfi");
5740 #line 1023 "rx-decode.opc"
5741                 ID(rtfi);
5742
5743               }
5744             break;
5745           case 0x95:
5746               {
5747                 /** 0111 1111 1001 0101         rte */
5748                 if (trace)
5749                   {
5750                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5751                            "/** 0111 1111 1001 0101             rte */",
5752                            op[0], op[1]);
5753                   }
5754                 SYNTAX("rte");
5755 #line 1026 "rx-decode.opc"
5756                 ID(rte);
5757
5758               }
5759             break;
5760           case 0x96:
5761               {
5762                 /** 0111 1111 1001 0110         wait */
5763                 if (trace)
5764                   {
5765                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5766                            "/** 0111 1111 1001 0110             wait */",
5767                            op[0], op[1]);
5768                   }
5769                 SYNTAX("wait");
5770 #line 1038 "rx-decode.opc"
5771                 ID(wait);
5772
5773               /*----------------------------------------------------------------------*/
5774               /* SCcnd                                                          */
5775
5776               }
5777             break;
5778           case 0xa0:
5779           case 0xa1:
5780           case 0xa2:
5781           case 0xa3:
5782           case 0xa4:
5783           case 0xa5:
5784           case 0xa6:
5785           case 0xa7:
5786           case 0xa8:
5787           case 0xa9:
5788           case 0xaa:
5789           case 0xab:
5790           case 0xac:
5791           case 0xad:
5792           case 0xae:
5793           case 0xaf:
5794               {
5795                 /** 0111 1111 1010 rdst                 setpsw  %0 */
5796 #line 999 "rx-decode.opc"
5797                 int rdst AU = op[1] & 0x0f;
5798                 if (trace)
5799                   {
5800                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5801                            "/** 0111 1111 1010 rdst                     setpsw  %0 */",
5802                            op[0], op[1]);
5803                     printf ("  rdst = 0x%x\n", rdst);
5804                   }
5805                 SYNTAX("setpsw  %0");
5806 #line 999 "rx-decode.opc"
5807                 ID(setpsw); DF(rdst);
5808
5809               }
5810             break;
5811           case 0xb0:
5812           case 0xb1:
5813           case 0xb2:
5814           case 0xb3:
5815           case 0xb4:
5816           case 0xb5:
5817           case 0xb6:
5818           case 0xb7:
5819           case 0xb8:
5820           case 0xb9:
5821           case 0xba:
5822           case 0xbb:
5823           case 0xbc:
5824           case 0xbd:
5825           case 0xbe:
5826           case 0xbf:
5827               {
5828                 /** 0111 1111 1011 rdst                 clrpsw  %0 */
5829 #line 996 "rx-decode.opc"
5830                 int rdst AU = op[1] & 0x0f;
5831                 if (trace)
5832                   {
5833                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5834                            "/** 0111 1111 1011 rdst                     clrpsw  %0 */",
5835                            op[0], op[1]);
5836                     printf ("  rdst = 0x%x\n", rdst);
5837                   }
5838                 SYNTAX("clrpsw  %0");
5839 #line 996 "rx-decode.opc"
5840                 ID(clrpsw); DF(rdst);
5841
5842               }
5843             break;
5844           default: UNSUPPORTED(); break;
5845         }
5846       break;
5847     case 0x80:
5848         GETBYTE ();
5849         switch (op[1] & 0x00)
5850         {
5851           case 0x00:
5852             op_semantics_39:
5853               {
5854                 /** 10sz 0dsp a dst b src       mov%s   %1, %0 */
5855 #line 336 "rx-decode.opc"
5856                 int sz AU = (op[0] >> 4) & 0x03;
5857 #line 336 "rx-decode.opc"
5858                 int dsp AU = op[0] & 0x07;
5859 #line 336 "rx-decode.opc"
5860                 int a AU = (op[1] >> 7) & 0x01;
5861 #line 336 "rx-decode.opc"
5862                 int dst AU = (op[1] >> 4) & 0x07;
5863 #line 336 "rx-decode.opc"
5864                 int b AU = (op[1] >> 3) & 0x01;
5865 #line 336 "rx-decode.opc"
5866                 int src AU = op[1] & 0x07;
5867                 if (trace)
5868                   {
5869                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5870                            "/** 10sz 0dsp a dst b src   mov%s   %1, %0 */",
5871                            op[0], op[1]);
5872                     printf ("  sz = 0x%x,", sz);
5873                     printf ("  dsp = 0x%x,", dsp);
5874                     printf ("  a = 0x%x,", a);
5875                     printf ("  dst = 0x%x,", dst);
5876                     printf ("  b = 0x%x,", b);
5877                     printf ("  src = 0x%x\n", src);
5878                   }
5879                 SYNTAX("mov%s   %1, %0");
5880 #line 336 "rx-decode.opc"
5881                 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
5882
5883               }
5884             break;
5885         }
5886       break;
5887     case 0x81:
5888         GETBYTE ();
5889         switch (op[1] & 0x00)
5890         {
5891           case 0x00:
5892             goto op_semantics_39;
5893             break;
5894         }
5895       break;
5896     case 0x82:
5897         GETBYTE ();
5898         switch (op[1] & 0x00)
5899         {
5900           case 0x00:
5901             goto op_semantics_39;
5902             break;
5903         }
5904       break;
5905     case 0x83:
5906         GETBYTE ();
5907         switch (op[1] & 0x00)
5908         {
5909           case 0x00:
5910             goto op_semantics_39;
5911             break;
5912         }
5913       break;
5914     case 0x84:
5915         GETBYTE ();
5916         switch (op[1] & 0x00)
5917         {
5918           case 0x00:
5919             goto op_semantics_39;
5920             break;
5921         }
5922       break;
5923     case 0x85:
5924         GETBYTE ();
5925         switch (op[1] & 0x00)
5926         {
5927           case 0x00:
5928             goto op_semantics_39;
5929             break;
5930         }
5931       break;
5932     case 0x86:
5933         GETBYTE ();
5934         switch (op[1] & 0x00)
5935         {
5936           case 0x00:
5937             goto op_semantics_39;
5938             break;
5939         }
5940       break;
5941     case 0x87:
5942         GETBYTE ();
5943         switch (op[1] & 0x00)
5944         {
5945           case 0x00:
5946             goto op_semantics_39;
5947             break;
5948         }
5949       break;
5950     case 0x88:
5951         GETBYTE ();
5952         switch (op[1] & 0x00)
5953         {
5954           case 0x00:
5955             op_semantics_40:
5956               {
5957                 /** 10sz 1dsp a src b dst       mov%s   %1, %0 */
5958 #line 333 "rx-decode.opc"
5959                 int sz AU = (op[0] >> 4) & 0x03;
5960 #line 333 "rx-decode.opc"
5961                 int dsp AU = op[0] & 0x07;
5962 #line 333 "rx-decode.opc"
5963                 int a AU = (op[1] >> 7) & 0x01;
5964 #line 333 "rx-decode.opc"
5965                 int src AU = (op[1] >> 4) & 0x07;
5966 #line 333 "rx-decode.opc"
5967                 int b AU = (op[1] >> 3) & 0x01;
5968 #line 333 "rx-decode.opc"
5969                 int dst AU = op[1] & 0x07;
5970                 if (trace)
5971                   {
5972                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5973                            "/** 10sz 1dsp a src b dst   mov%s   %1, %0 */",
5974                            op[0], op[1]);
5975                     printf ("  sz = 0x%x,", sz);
5976                     printf ("  dsp = 0x%x,", dsp);
5977                     printf ("  a = 0x%x,", a);
5978                     printf ("  src = 0x%x,", src);
5979                     printf ("  b = 0x%x,", b);
5980                     printf ("  dst = 0x%x\n", dst);
5981                   }
5982                 SYNTAX("mov%s   %1, %0");
5983 #line 333 "rx-decode.opc"
5984                 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
5985
5986               }
5987             break;
5988         }
5989       break;
5990     case 0x89:
5991         GETBYTE ();
5992         switch (op[1] & 0x00)
5993         {
5994           case 0x00:
5995             goto op_semantics_40;
5996             break;
5997         }
5998       break;
5999     case 0x8a:
6000         GETBYTE ();
6001         switch (op[1] & 0x00)
6002         {
6003           case 0x00:
6004             goto op_semantics_40;
6005             break;
6006         }
6007       break;
6008     case 0x8b:
6009         GETBYTE ();
6010         switch (op[1] & 0x00)
6011         {
6012           case 0x00:
6013             goto op_semantics_40;
6014             break;
6015         }
6016       break;
6017     case 0x8c:
6018         GETBYTE ();
6019         switch (op[1] & 0x00)
6020         {
6021           case 0x00:
6022             goto op_semantics_40;
6023             break;
6024         }
6025       break;
6026     case 0x8d:
6027         GETBYTE ();
6028         switch (op[1] & 0x00)
6029         {
6030           case 0x00:
6031             goto op_semantics_40;
6032             break;
6033         }
6034       break;
6035     case 0x8e:
6036         GETBYTE ();
6037         switch (op[1] & 0x00)
6038         {
6039           case 0x00:
6040             goto op_semantics_40;
6041             break;
6042         }
6043       break;
6044     case 0x8f:
6045         GETBYTE ();
6046         switch (op[1] & 0x00)
6047         {
6048           case 0x00:
6049             goto op_semantics_40;
6050             break;
6051         }
6052       break;
6053     case 0x90:
6054         GETBYTE ();
6055         switch (op[1] & 0x00)
6056         {
6057           case 0x00:
6058             goto op_semantics_39;
6059             break;
6060         }
6061       break;
6062     case 0x91:
6063         GETBYTE ();
6064         switch (op[1] & 0x00)
6065         {
6066           case 0x00:
6067             goto op_semantics_39;
6068             break;
6069         }
6070       break;
6071     case 0x92:
6072         GETBYTE ();
6073         switch (op[1] & 0x00)
6074         {
6075           case 0x00:
6076             goto op_semantics_39;
6077             break;
6078         }
6079       break;
6080     case 0x93:
6081         GETBYTE ();
6082         switch (op[1] & 0x00)
6083         {
6084           case 0x00:
6085             goto op_semantics_39;
6086             break;
6087         }
6088       break;
6089     case 0x94:
6090         GETBYTE ();
6091         switch (op[1] & 0x00)
6092         {
6093           case 0x00:
6094             goto op_semantics_39;
6095             break;
6096         }
6097       break;
6098     case 0x95:
6099         GETBYTE ();
6100         switch (op[1] & 0x00)
6101         {
6102           case 0x00:
6103             goto op_semantics_39;
6104             break;
6105         }
6106       break;
6107     case 0x96:
6108         GETBYTE ();
6109         switch (op[1] & 0x00)
6110         {
6111           case 0x00:
6112             goto op_semantics_39;
6113             break;
6114         }
6115       break;
6116     case 0x97:
6117         GETBYTE ();
6118         switch (op[1] & 0x00)
6119         {
6120           case 0x00:
6121             goto op_semantics_39;
6122             break;
6123         }
6124       break;
6125     case 0x98:
6126         GETBYTE ();
6127         switch (op[1] & 0x00)
6128         {
6129           case 0x00:
6130             goto op_semantics_40;
6131             break;
6132         }
6133       break;
6134     case 0x99:
6135         GETBYTE ();
6136         switch (op[1] & 0x00)
6137         {
6138           case 0x00:
6139             goto op_semantics_40;
6140             break;
6141         }
6142       break;
6143     case 0x9a:
6144         GETBYTE ();
6145         switch (op[1] & 0x00)
6146         {
6147           case 0x00:
6148             goto op_semantics_40;
6149             break;
6150         }
6151       break;
6152     case 0x9b:
6153         GETBYTE ();
6154         switch (op[1] & 0x00)
6155         {
6156           case 0x00:
6157             goto op_semantics_40;
6158             break;
6159         }
6160       break;
6161     case 0x9c:
6162         GETBYTE ();
6163         switch (op[1] & 0x00)
6164         {
6165           case 0x00:
6166             goto op_semantics_40;
6167             break;
6168         }
6169       break;
6170     case 0x9d:
6171         GETBYTE ();
6172         switch (op[1] & 0x00)
6173         {
6174           case 0x00:
6175             goto op_semantics_40;
6176             break;
6177         }
6178       break;
6179     case 0x9e:
6180         GETBYTE ();
6181         switch (op[1] & 0x00)
6182         {
6183           case 0x00:
6184             goto op_semantics_40;
6185             break;
6186         }
6187       break;
6188     case 0x9f:
6189         GETBYTE ();
6190         switch (op[1] & 0x00)
6191         {
6192           case 0x00:
6193             goto op_semantics_40;
6194             break;
6195         }
6196       break;
6197     case 0xa0:
6198         GETBYTE ();
6199         switch (op[1] & 0x00)
6200         {
6201           case 0x00:
6202             goto op_semantics_39;
6203             break;
6204         }
6205       break;
6206     case 0xa1:
6207         GETBYTE ();
6208         switch (op[1] & 0x00)
6209         {
6210           case 0x00:
6211             goto op_semantics_39;
6212             break;
6213         }
6214       break;
6215     case 0xa2:
6216         GETBYTE ();
6217         switch (op[1] & 0x00)
6218         {
6219           case 0x00:
6220             goto op_semantics_39;
6221             break;
6222         }
6223       break;
6224     case 0xa3:
6225         GETBYTE ();
6226         switch (op[1] & 0x00)
6227         {
6228           case 0x00:
6229             goto op_semantics_39;
6230             break;
6231         }
6232       break;
6233     case 0xa4:
6234         GETBYTE ();
6235         switch (op[1] & 0x00)
6236         {
6237           case 0x00:
6238             goto op_semantics_39;
6239             break;
6240         }
6241       break;
6242     case 0xa5:
6243         GETBYTE ();
6244         switch (op[1] & 0x00)
6245         {
6246           case 0x00:
6247             goto op_semantics_39;
6248             break;
6249         }
6250       break;
6251     case 0xa6:
6252         GETBYTE ();
6253         switch (op[1] & 0x00)
6254         {
6255           case 0x00:
6256             goto op_semantics_39;
6257             break;
6258         }
6259       break;
6260     case 0xa7:
6261         GETBYTE ();
6262         switch (op[1] & 0x00)
6263         {
6264           case 0x00:
6265             goto op_semantics_39;
6266             break;
6267         }
6268       break;
6269     case 0xa8:
6270         GETBYTE ();
6271         switch (op[1] & 0x00)
6272         {
6273           case 0x00:
6274             goto op_semantics_40;
6275             break;
6276         }
6277       break;
6278     case 0xa9:
6279         GETBYTE ();
6280         switch (op[1] & 0x00)
6281         {
6282           case 0x00:
6283             goto op_semantics_40;
6284             break;
6285         }
6286       break;
6287     case 0xaa:
6288         GETBYTE ();
6289         switch (op[1] & 0x00)
6290         {
6291           case 0x00:
6292             goto op_semantics_40;
6293             break;
6294         }
6295       break;
6296     case 0xab:
6297         GETBYTE ();
6298         switch (op[1] & 0x00)
6299         {
6300           case 0x00:
6301             goto op_semantics_40;
6302             break;
6303         }
6304       break;
6305     case 0xac:
6306         GETBYTE ();
6307         switch (op[1] & 0x00)
6308         {
6309           case 0x00:
6310             goto op_semantics_40;
6311             break;
6312         }
6313       break;
6314     case 0xad:
6315         GETBYTE ();
6316         switch (op[1] & 0x00)
6317         {
6318           case 0x00:
6319             goto op_semantics_40;
6320             break;
6321         }
6322       break;
6323     case 0xae:
6324         GETBYTE ();
6325         switch (op[1] & 0x00)
6326         {
6327           case 0x00:
6328             goto op_semantics_40;
6329             break;
6330         }
6331       break;
6332     case 0xaf:
6333         GETBYTE ();
6334         switch (op[1] & 0x00)
6335         {
6336           case 0x00:
6337             goto op_semantics_40;
6338             break;
6339         }
6340       break;
6341     case 0xb0:
6342         GETBYTE ();
6343         switch (op[1] & 0x00)
6344         {
6345           case 0x00:
6346             op_semantics_41:
6347               {
6348                 /** 1011 w dsp a src b dst      movu%s  %1, %0 */
6349 #line 356 "rx-decode.opc"
6350                 int w AU = (op[0] >> 3) & 0x01;
6351 #line 356 "rx-decode.opc"
6352                 int dsp AU = op[0] & 0x07;
6353 #line 356 "rx-decode.opc"
6354                 int a AU = (op[1] >> 7) & 0x01;
6355 #line 356 "rx-decode.opc"
6356                 int src AU = (op[1] >> 4) & 0x07;
6357 #line 356 "rx-decode.opc"
6358                 int b AU = (op[1] >> 3) & 0x01;
6359 #line 356 "rx-decode.opc"
6360                 int dst AU = op[1] & 0x07;
6361                 if (trace)
6362                   {
6363                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6364                            "/** 1011 w dsp a src b dst  movu%s  %1, %0 */",
6365                            op[0], op[1]);
6366                     printf ("  w = 0x%x,", w);
6367                     printf ("  dsp = 0x%x,", dsp);
6368                     printf ("  a = 0x%x,", a);
6369                     printf ("  src = 0x%x,", src);
6370                     printf ("  b = 0x%x,", b);
6371                     printf ("  dst = 0x%x\n", dst);
6372                   }
6373                 SYNTAX("movu%s  %1, %0");
6374 #line 356 "rx-decode.opc"
6375                 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
6376
6377               }
6378             break;
6379         }
6380       break;
6381     case 0xb1:
6382         GETBYTE ();
6383         switch (op[1] & 0x00)
6384         {
6385           case 0x00:
6386             goto op_semantics_41;
6387             break;
6388         }
6389       break;
6390     case 0xb2:
6391         GETBYTE ();
6392         switch (op[1] & 0x00)
6393         {
6394           case 0x00:
6395             goto op_semantics_41;
6396             break;
6397         }
6398       break;
6399     case 0xb3:
6400         GETBYTE ();
6401         switch (op[1] & 0x00)
6402         {
6403           case 0x00:
6404             goto op_semantics_41;
6405             break;
6406         }
6407       break;
6408     case 0xb4:
6409         GETBYTE ();
6410         switch (op[1] & 0x00)
6411         {
6412           case 0x00:
6413             goto op_semantics_41;
6414             break;
6415         }
6416       break;
6417     case 0xb5:
6418         GETBYTE ();
6419         switch (op[1] & 0x00)
6420         {
6421           case 0x00:
6422             goto op_semantics_41;
6423             break;
6424         }
6425       break;
6426     case 0xb6:
6427         GETBYTE ();
6428         switch (op[1] & 0x00)
6429         {
6430           case 0x00:
6431             goto op_semantics_41;
6432             break;
6433         }
6434       break;
6435     case 0xb7:
6436         GETBYTE ();
6437         switch (op[1] & 0x00)
6438         {
6439           case 0x00:
6440             goto op_semantics_41;
6441             break;
6442         }
6443       break;
6444     case 0xb8:
6445         GETBYTE ();
6446         switch (op[1] & 0x00)
6447         {
6448           case 0x00:
6449             goto op_semantics_41;
6450             break;
6451         }
6452       break;
6453     case 0xb9:
6454         GETBYTE ();
6455         switch (op[1] & 0x00)
6456         {
6457           case 0x00:
6458             goto op_semantics_41;
6459             break;
6460         }
6461       break;
6462     case 0xba:
6463         GETBYTE ();
6464         switch (op[1] & 0x00)
6465         {
6466           case 0x00:
6467             goto op_semantics_41;
6468             break;
6469         }
6470       break;
6471     case 0xbb:
6472         GETBYTE ();
6473         switch (op[1] & 0x00)
6474         {
6475           case 0x00:
6476             goto op_semantics_41;
6477             break;
6478         }
6479       break;
6480     case 0xbc:
6481         GETBYTE ();
6482         switch (op[1] & 0x00)
6483         {
6484           case 0x00:
6485             goto op_semantics_41;
6486             break;
6487         }
6488       break;
6489     case 0xbd:
6490         GETBYTE ();
6491         switch (op[1] & 0x00)
6492         {
6493           case 0x00:
6494             goto op_semantics_41;
6495             break;
6496         }
6497       break;
6498     case 0xbe:
6499         GETBYTE ();
6500         switch (op[1] & 0x00)
6501         {
6502           case 0x00:
6503             goto op_semantics_41;
6504             break;
6505         }
6506       break;
6507     case 0xbf:
6508         GETBYTE ();
6509         switch (op[1] & 0x00)
6510         {
6511           case 0x00:
6512             goto op_semantics_41;
6513             break;
6514         }
6515       break;
6516     case 0xc0:
6517         GETBYTE ();
6518         switch (op[1] & 0x00)
6519         {
6520           case 0x00:
6521             op_semantics_42:
6522               {
6523                 /** 11sz sd ss rsrc rdst        mov%s   %1, %0 */
6524 #line 314 "rx-decode.opc"
6525                 int sz AU = (op[0] >> 4) & 0x03;
6526 #line 314 "rx-decode.opc"
6527                 int sd AU = (op[0] >> 2) & 0x03;
6528 #line 314 "rx-decode.opc"
6529                 int ss AU = op[0] & 0x03;
6530 #line 314 "rx-decode.opc"
6531                 int rsrc AU = (op[1] >> 4) & 0x0f;
6532 #line 314 "rx-decode.opc"
6533                 int rdst AU = op[1] & 0x0f;
6534                 if (trace)
6535                   {
6536                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6537                            "/** 11sz sd ss rsrc rdst    mov%s   %1, %0 */",
6538                            op[0], op[1]);
6539                     printf ("  sz = 0x%x,", sz);
6540                     printf ("  sd = 0x%x,", sd);
6541                     printf ("  ss = 0x%x,", ss);
6542                     printf ("  rsrc = 0x%x,", rsrc);
6543                     printf ("  rdst = 0x%x\n", rdst);
6544                   }
6545                 SYNTAX("mov%s   %1, %0");
6546 #line 314 "rx-decode.opc"
6547                 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
6548                   {
6549                     ID(nop2);
6550                     SYNTAX ("nop\t; mov.l\tr0, r0");
6551                   }
6552                 else
6553                   {
6554                     ID(mov); sBWL(sz); F_____;
6555                     if ((ss == 3) && (sd != 3))
6556                 {
6557                   SD(ss, rdst, sz); DD(sd, rsrc, sz);
6558                 }
6559                     else
6560                 {
6561                   SD(ss, rsrc, sz); DD(sd, rdst, sz);
6562                 }
6563                   }
6564
6565               }
6566             break;
6567         }
6568       break;
6569     case 0xc1:
6570         GETBYTE ();
6571         switch (op[1] & 0x00)
6572         {
6573           case 0x00:
6574             goto op_semantics_42;
6575             break;
6576         }
6577       break;
6578     case 0xc2:
6579         GETBYTE ();
6580         switch (op[1] & 0x00)
6581         {
6582           case 0x00:
6583             goto op_semantics_42;
6584             break;
6585         }
6586       break;
6587     case 0xc3:
6588         GETBYTE ();
6589         switch (op[1] & 0x00)
6590         {
6591           case 0x00:
6592             goto op_semantics_42;
6593             break;
6594         }
6595       break;
6596     case 0xc4:
6597         GETBYTE ();
6598         switch (op[1] & 0x00)
6599         {
6600           case 0x00:
6601             goto op_semantics_42;
6602             break;
6603         }
6604       break;
6605     case 0xc5:
6606         GETBYTE ();
6607         switch (op[1] & 0x00)
6608         {
6609           case 0x00:
6610             goto op_semantics_42;
6611             break;
6612         }
6613       break;
6614     case 0xc6:
6615         GETBYTE ();
6616         switch (op[1] & 0x00)
6617         {
6618           case 0x00:
6619             goto op_semantics_42;
6620             break;
6621         }
6622       break;
6623     case 0xc7:
6624         GETBYTE ();
6625         switch (op[1] & 0x00)
6626         {
6627           case 0x00:
6628             goto op_semantics_42;
6629             break;
6630         }
6631       break;
6632     case 0xc8:
6633         GETBYTE ();
6634         switch (op[1] & 0x00)
6635         {
6636           case 0x00:
6637             goto op_semantics_42;
6638             break;
6639         }
6640       break;
6641     case 0xc9:
6642         GETBYTE ();
6643         switch (op[1] & 0x00)
6644         {
6645           case 0x00:
6646             goto op_semantics_42;
6647             break;
6648         }
6649       break;
6650     case 0xca:
6651         GETBYTE ();
6652         switch (op[1] & 0x00)
6653         {
6654           case 0x00:
6655             goto op_semantics_42;
6656             break;
6657         }
6658       break;
6659     case 0xcb:
6660         GETBYTE ();
6661         switch (op[1] & 0x00)
6662         {
6663           case 0x00:
6664             goto op_semantics_42;
6665             break;
6666         }
6667       break;
6668     case 0xcc:
6669         GETBYTE ();
6670         switch (op[1] & 0x00)
6671         {
6672           case 0x00:
6673             goto op_semantics_42;
6674             break;
6675         }
6676       break;
6677     case 0xcd:
6678         GETBYTE ();
6679         switch (op[1] & 0x00)
6680         {
6681           case 0x00:
6682             goto op_semantics_42;
6683             break;
6684         }
6685       break;
6686     case 0xce:
6687         GETBYTE ();
6688         switch (op[1] & 0x00)
6689         {
6690           case 0x00:
6691             goto op_semantics_42;
6692             break;
6693         }
6694       break;
6695     case 0xcf:
6696         GETBYTE ();
6697         switch (op[1] & 0x00)
6698         {
6699           case 0x00:
6700             goto op_semantics_42;
6701             break;
6702         }
6703       break;
6704     case 0xd0:
6705         GETBYTE ();
6706         switch (op[1] & 0x00)
6707         {
6708           case 0x00:
6709             goto op_semantics_42;
6710             break;
6711         }
6712       break;
6713     case 0xd1:
6714         GETBYTE ();
6715         switch (op[1] & 0x00)
6716         {
6717           case 0x00:
6718             goto op_semantics_42;
6719             break;
6720         }
6721       break;
6722     case 0xd2:
6723         GETBYTE ();
6724         switch (op[1] & 0x00)
6725         {
6726           case 0x00:
6727             goto op_semantics_42;
6728             break;
6729         }
6730       break;
6731     case 0xd3:
6732         GETBYTE ();
6733         switch (op[1] & 0x00)
6734         {
6735           case 0x00:
6736             goto op_semantics_42;
6737             break;
6738         }
6739       break;
6740     case 0xd4:
6741         GETBYTE ();
6742         switch (op[1] & 0x00)
6743         {
6744           case 0x00:
6745             goto op_semantics_42;
6746             break;
6747         }
6748       break;
6749     case 0xd5:
6750         GETBYTE ();
6751         switch (op[1] & 0x00)
6752         {
6753           case 0x00:
6754             goto op_semantics_42;
6755             break;
6756         }
6757       break;
6758     case 0xd6:
6759         GETBYTE ();
6760         switch (op[1] & 0x00)
6761         {
6762           case 0x00:
6763             goto op_semantics_42;
6764             break;
6765         }
6766       break;
6767     case 0xd7:
6768         GETBYTE ();
6769         switch (op[1] & 0x00)
6770         {
6771           case 0x00:
6772             goto op_semantics_42;
6773             break;
6774         }
6775       break;
6776     case 0xd8:
6777         GETBYTE ();
6778         switch (op[1] & 0x00)
6779         {
6780           case 0x00:
6781             goto op_semantics_42;
6782             break;
6783         }
6784       break;
6785     case 0xd9:
6786         GETBYTE ();
6787         switch (op[1] & 0x00)
6788         {
6789           case 0x00:
6790             goto op_semantics_42;
6791             break;
6792         }
6793       break;
6794     case 0xda:
6795         GETBYTE ();
6796         switch (op[1] & 0x00)
6797         {
6798           case 0x00:
6799             goto op_semantics_42;
6800             break;
6801         }
6802       break;
6803     case 0xdb:
6804         GETBYTE ();
6805         switch (op[1] & 0x00)
6806         {
6807           case 0x00:
6808             goto op_semantics_42;
6809             break;
6810         }
6811       break;
6812     case 0xdc:
6813         GETBYTE ();
6814         switch (op[1] & 0x00)
6815         {
6816           case 0x00:
6817             goto op_semantics_42;
6818             break;
6819         }
6820       break;
6821     case 0xdd:
6822         GETBYTE ();
6823         switch (op[1] & 0x00)
6824         {
6825           case 0x00:
6826             goto op_semantics_42;
6827             break;
6828         }
6829       break;
6830     case 0xde:
6831         GETBYTE ();
6832         switch (op[1] & 0x00)
6833         {
6834           case 0x00:
6835             goto op_semantics_42;
6836             break;
6837         }
6838       break;
6839     case 0xdf:
6840         GETBYTE ();
6841         switch (op[1] & 0x00)
6842         {
6843           case 0x00:
6844             goto op_semantics_42;
6845             break;
6846         }
6847       break;
6848     case 0xe0:
6849         GETBYTE ();
6850         switch (op[1] & 0x00)
6851         {
6852           case 0x00:
6853             goto op_semantics_42;
6854             break;
6855         }
6856       break;
6857     case 0xe1:
6858         GETBYTE ();
6859         switch (op[1] & 0x00)
6860         {
6861           case 0x00:
6862             goto op_semantics_42;
6863             break;
6864         }
6865       break;
6866     case 0xe2:
6867         GETBYTE ();
6868         switch (op[1] & 0x00)
6869         {
6870           case 0x00:
6871             goto op_semantics_42;
6872             break;
6873         }
6874       break;
6875     case 0xe3:
6876         GETBYTE ();
6877         switch (op[1] & 0x00)
6878         {
6879           case 0x00:
6880             goto op_semantics_42;
6881             break;
6882         }
6883       break;
6884     case 0xe4:
6885         GETBYTE ();
6886         switch (op[1] & 0x00)
6887         {
6888           case 0x00:
6889             goto op_semantics_42;
6890             break;
6891         }
6892       break;
6893     case 0xe5:
6894         GETBYTE ();
6895         switch (op[1] & 0x00)
6896         {
6897           case 0x00:
6898             goto op_semantics_42;
6899             break;
6900         }
6901       break;
6902     case 0xe6:
6903         GETBYTE ();
6904         switch (op[1] & 0x00)
6905         {
6906           case 0x00:
6907             goto op_semantics_42;
6908             break;
6909         }
6910       break;
6911     case 0xe7:
6912         GETBYTE ();
6913         switch (op[1] & 0x00)
6914         {
6915           case 0x00:
6916             goto op_semantics_42;
6917             break;
6918         }
6919       break;
6920     case 0xe8:
6921         GETBYTE ();
6922         switch (op[1] & 0x00)
6923         {
6924           case 0x00:
6925             goto op_semantics_42;
6926             break;
6927         }
6928       break;
6929     case 0xe9:
6930         GETBYTE ();
6931         switch (op[1] & 0x00)
6932         {
6933           case 0x00:
6934             goto op_semantics_42;
6935             break;
6936         }
6937       break;
6938     case 0xea:
6939         GETBYTE ();
6940         switch (op[1] & 0x00)
6941         {
6942           case 0x00:
6943             goto op_semantics_42;
6944             break;
6945         }
6946       break;
6947     case 0xeb:
6948         GETBYTE ();
6949         switch (op[1] & 0x00)
6950         {
6951           case 0x00:
6952             goto op_semantics_42;
6953             break;
6954         }
6955       break;
6956     case 0xec:
6957         GETBYTE ();
6958         switch (op[1] & 0x00)
6959         {
6960           case 0x00:
6961             goto op_semantics_42;
6962             break;
6963         }
6964       break;
6965     case 0xed:
6966         GETBYTE ();
6967         switch (op[1] & 0x00)
6968         {
6969           case 0x00:
6970             goto op_semantics_42;
6971             break;
6972         }
6973       break;
6974     case 0xee:
6975         GETBYTE ();
6976         switch (op[1] & 0x00)
6977         {
6978           case 0x00:
6979             goto op_semantics_42;
6980             break;
6981         }
6982       break;
6983     case 0xef:
6984         GETBYTE ();
6985         switch (op[1] & 0x00)
6986         {
6987           case 0x00:
6988             goto op_semantics_42;
6989             break;
6990         }
6991       break;
6992     case 0xf0:
6993         GETBYTE ();
6994         switch (op[1] & 0x08)
6995         {
6996           case 0x00:
6997             op_semantics_43:
6998               {
6999                 /** 1111 00sd rdst 0bit                 bset    #%1, %0%S0 */
7000 #line 939 "rx-decode.opc"
7001                 int sd AU = op[0] & 0x03;
7002 #line 939 "rx-decode.opc"
7003                 int rdst AU = (op[1] >> 4) & 0x0f;
7004 #line 939 "rx-decode.opc"
7005                 int bit AU = op[1] & 0x07;
7006                 if (trace)
7007                   {
7008                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7009                            "/** 1111 00sd rdst 0bit                     bset    #%1, %0%S0 */",
7010                            op[0], op[1]);
7011                     printf ("  sd = 0x%x,", sd);
7012                     printf ("  rdst = 0x%x,", rdst);
7013                     printf ("  bit = 0x%x\n", bit);
7014                   }
7015                 SYNTAX("bset    #%1, %0%S0");
7016 #line 939 "rx-decode.opc"
7017                 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
7018
7019               }
7020             break;
7021           case 0x08:
7022             op_semantics_44:
7023               {
7024                 /** 1111 00sd rdst 1bit                 bclr    #%1, %0%S0 */
7025 #line 951 "rx-decode.opc"
7026                 int sd AU = op[0] & 0x03;
7027 #line 951 "rx-decode.opc"
7028                 int rdst AU = (op[1] >> 4) & 0x0f;
7029 #line 951 "rx-decode.opc"
7030                 int bit AU = op[1] & 0x07;
7031                 if (trace)
7032                   {
7033                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7034                            "/** 1111 00sd rdst 1bit                     bclr    #%1, %0%S0 */",
7035                            op[0], op[1]);
7036                     printf ("  sd = 0x%x,", sd);
7037                     printf ("  rdst = 0x%x,", rdst);
7038                     printf ("  bit = 0x%x\n", bit);
7039                   }
7040                 SYNTAX("bclr    #%1, %0%S0");
7041 #line 951 "rx-decode.opc"
7042                 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
7043
7044               }
7045             break;
7046         }
7047       break;
7048     case 0xf1:
7049         GETBYTE ();
7050         switch (op[1] & 0x08)
7051         {
7052           case 0x00:
7053             goto op_semantics_43;
7054             break;
7055           case 0x08:
7056             goto op_semantics_44;
7057             break;
7058         }
7059       break;
7060     case 0xf2:
7061         GETBYTE ();
7062         switch (op[1] & 0x08)
7063         {
7064           case 0x00:
7065             goto op_semantics_43;
7066             break;
7067           case 0x08:
7068             goto op_semantics_44;
7069             break;
7070         }
7071       break;
7072     case 0xf3:
7073         GETBYTE ();
7074         switch (op[1] & 0x08)
7075         {
7076           case 0x00:
7077             goto op_semantics_43;
7078             break;
7079           case 0x08:
7080             goto op_semantics_44;
7081             break;
7082         }
7083       break;
7084     case 0xf4:
7085         GETBYTE ();
7086         switch (op[1] & 0x0c)
7087         {
7088           case 0x00:
7089           case 0x04:
7090             op_semantics_45:
7091               {
7092                 /** 1111 01sd rdst 0bit                 btst    #%2, %1%S1 */
7093 #line 963 "rx-decode.opc"
7094                 int sd AU = op[0] & 0x03;
7095 #line 963 "rx-decode.opc"
7096                 int rdst AU = (op[1] >> 4) & 0x0f;
7097 #line 963 "rx-decode.opc"
7098                 int bit AU = op[1] & 0x07;
7099                 if (trace)
7100                   {
7101                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7102                            "/** 1111 01sd rdst 0bit                     btst    #%2, %1%S1 */",
7103                            op[0], op[1]);
7104                     printf ("  sd = 0x%x,", sd);
7105                     printf ("  rdst = 0x%x,", rdst);
7106                     printf ("  bit = 0x%x\n", bit);
7107                   }
7108                 SYNTAX("btst    #%2, %1%S1");
7109 #line 963 "rx-decode.opc"
7110                 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
7111
7112               }
7113             break;
7114           case 0x08:
7115             op_semantics_46:
7116               {
7117                 /** 1111 01ss rsrc 10sz         push%s  %1 */
7118 #line 381 "rx-decode.opc"
7119                 int ss AU = op[0] & 0x03;
7120 #line 381 "rx-decode.opc"
7121                 int rsrc AU = (op[1] >> 4) & 0x0f;
7122 #line 381 "rx-decode.opc"
7123                 int sz AU = op[1] & 0x03;
7124                 if (trace)
7125                   {
7126                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7127                            "/** 1111 01ss rsrc 10sz             push%s  %1 */",
7128                            op[0], op[1]);
7129                     printf ("  ss = 0x%x,", ss);
7130                     printf ("  rsrc = 0x%x,", rsrc);
7131                     printf ("  sz = 0x%x\n", sz);
7132                   }
7133                 SYNTAX("push%s  %1");
7134 #line 381 "rx-decode.opc"
7135                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
7136
7137               /*----------------------------------------------------------------------*/
7138               /* XCHG                                                                   */
7139
7140               }
7141             break;
7142           default: UNSUPPORTED(); break;
7143         }
7144       break;
7145     case 0xf5:
7146         GETBYTE ();
7147         switch (op[1] & 0x0c)
7148         {
7149           case 0x00:
7150           case 0x04:
7151             goto op_semantics_45;
7152             break;
7153           case 0x08:
7154             goto op_semantics_46;
7155             break;
7156           default: UNSUPPORTED(); break;
7157         }
7158       break;
7159     case 0xf6:
7160         GETBYTE ();
7161         switch (op[1] & 0x0c)
7162         {
7163           case 0x00:
7164           case 0x04:
7165             goto op_semantics_45;
7166             break;
7167           case 0x08:
7168             goto op_semantics_46;
7169             break;
7170           default: UNSUPPORTED(); break;
7171         }
7172       break;
7173     case 0xf7:
7174         GETBYTE ();
7175         switch (op[1] & 0x0c)
7176         {
7177           case 0x00:
7178           case 0x04:
7179             goto op_semantics_45;
7180             break;
7181           case 0x08:
7182             goto op_semantics_46;
7183             break;
7184           default: UNSUPPORTED(); break;
7185         }
7186       break;
7187     case 0xf8:
7188         GETBYTE ();
7189         switch (op[1] & 0x00)
7190         {
7191           case 0x00:
7192             op_semantics_47:
7193               {
7194                 /** 1111 10sd rdst im sz        mov%s   #%1, %0 */
7195 #line 292 "rx-decode.opc"
7196                 int sd AU = op[0] & 0x03;
7197 #line 292 "rx-decode.opc"
7198                 int rdst AU = (op[1] >> 4) & 0x0f;
7199 #line 292 "rx-decode.opc"
7200                 int im AU = (op[1] >> 2) & 0x03;
7201 #line 292 "rx-decode.opc"
7202                 int sz AU = op[1] & 0x03;
7203                 if (trace)
7204                   {
7205                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7206                            "/** 1111 10sd rdst im sz    mov%s   #%1, %0 */",
7207                            op[0], op[1]);
7208                     printf ("  sd = 0x%x,", sd);
7209                     printf ("  rdst = 0x%x,", rdst);
7210                     printf ("  im = 0x%x,", im);
7211                     printf ("  sz = 0x%x\n", sz);
7212                   }
7213                 SYNTAX("mov%s   #%1, %0");
7214 #line 292 "rx-decode.opc"
7215                 ID(mov); DD(sd, rdst, sz);
7216                 if ((im == 1 && sz == 0)
7217                     || (im == 2 && sz == 1)
7218                     || (im == 0 && sz == 2))
7219                   {
7220                     BWL (sz);
7221                     SC(IMM(im));
7222                   }
7223                 else
7224                   {
7225                     sBWL (sz);
7226                     SC(IMMex(im));
7227                   }
7228                  F_____;
7229
7230               }
7231             break;
7232         }
7233       break;
7234     case 0xf9:
7235         GETBYTE ();
7236         switch (op[1] & 0x00)
7237         {
7238           case 0x00:
7239             goto op_semantics_47;
7240             break;
7241         }
7242       break;
7243     case 0xfa:
7244         GETBYTE ();
7245         switch (op[1] & 0x00)
7246         {
7247           case 0x00:
7248             goto op_semantics_47;
7249             break;
7250         }
7251       break;
7252     case 0xfb:
7253         GETBYTE ();
7254         switch (op[1] & 0x00)
7255         {
7256           case 0x00:
7257             goto op_semantics_47;
7258             break;
7259         }
7260       break;
7261     case 0xfc:
7262         GETBYTE ();
7263         switch (op[1] & 0xff)
7264         {
7265           case 0x03:
7266               GETBYTE ();
7267               switch (op[2] & 0x00)
7268               {
7269                 case 0x00:
7270                     {
7271                       /** 1111 1100 0000 0011 rsrc rdst sbb     %1, %0 */
7272 #line 555 "rx-decode.opc"
7273                       int rsrc AU = (op[2] >> 4) & 0x0f;
7274 #line 555 "rx-decode.opc"
7275                       int rdst AU = op[2] & 0x0f;
7276                       if (trace)
7277                         {
7278                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7279                                  "/** 1111 1100 0000 0011 rsrc rdst     sbb     %1, %0 */",
7280                                  op[0], op[1], op[2]);
7281                           printf ("  rsrc = 0x%x,", rsrc);
7282                           printf ("  rdst = 0x%x\n", rdst);
7283                         }
7284                       SYNTAX("sbb       %1, %0");
7285 #line 555 "rx-decode.opc"
7286                       ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
7287
7288                       /* FIXME: only supports .L */
7289                     }
7290                   break;
7291               }
7292             break;
7293           case 0x07:
7294               GETBYTE ();
7295               switch (op[2] & 0x00)
7296               {
7297                 case 0x00:
7298                     {
7299                       /** 1111 1100 0000 0111 rsrc rdst neg     %2, %0 */
7300 #line 486 "rx-decode.opc"
7301                       int rsrc AU = (op[2] >> 4) & 0x0f;
7302 #line 486 "rx-decode.opc"
7303                       int rdst AU = op[2] & 0x0f;
7304                       if (trace)
7305                         {
7306                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7307                                  "/** 1111 1100 0000 0111 rsrc rdst     neg     %2, %0 */",
7308                                  op[0], op[1], op[2]);
7309                           printf ("  rsrc = 0x%x,", rsrc);
7310                           printf ("  rdst = 0x%x\n", rdst);
7311                         }
7312                       SYNTAX("neg       %2, %0");
7313 #line 486 "rx-decode.opc"
7314                       ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
7315
7316                     /*----------------------------------------------------------------------*/
7317                     /* ADC                                                                      */
7318
7319                     }
7320                   break;
7321               }
7322             break;
7323           case 0x0b:
7324               GETBYTE ();
7325               switch (op[2] & 0x00)
7326               {
7327                 case 0x00:
7328                     {
7329                       /** 1111 1100 0000 1011 rsrc rdst adc     %1, %0 */
7330 #line 495 "rx-decode.opc"
7331                       int rsrc AU = (op[2] >> 4) & 0x0f;
7332 #line 495 "rx-decode.opc"
7333                       int rdst AU = op[2] & 0x0f;
7334                       if (trace)
7335                         {
7336                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7337                                  "/** 1111 1100 0000 1011 rsrc rdst     adc     %1, %0 */",
7338                                  op[0], op[1], op[2]);
7339                           printf ("  rsrc = 0x%x,", rsrc);
7340                           printf ("  rdst = 0x%x\n", rdst);
7341                         }
7342                       SYNTAX("adc       %1, %0");
7343 #line 495 "rx-decode.opc"
7344                       ID(adc); SR(rsrc); DR(rdst); F_OSZC;
7345
7346                     }
7347                   break;
7348               }
7349             break;
7350           case 0x0f:
7351               GETBYTE ();
7352               switch (op[2] & 0x00)
7353               {
7354                 case 0x00:
7355                     {
7356                       /** 1111 1100 0000 1111 rsrc rdst abs     %1, %0 */
7357 #line 568 "rx-decode.opc"
7358                       int rsrc AU = (op[2] >> 4) & 0x0f;
7359 #line 568 "rx-decode.opc"
7360                       int rdst AU = op[2] & 0x0f;
7361                       if (trace)
7362                         {
7363                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7364                                  "/** 1111 1100 0000 1111 rsrc rdst     abs     %1, %0 */",
7365                                  op[0], op[1], op[2]);
7366                           printf ("  rsrc = 0x%x,", rsrc);
7367                           printf ("  rdst = 0x%x\n", rdst);
7368                         }
7369                       SYNTAX("abs       %1, %0");
7370 #line 568 "rx-decode.opc"
7371                       ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
7372
7373                     /*----------------------------------------------------------------------*/
7374                     /* MAX                                                                      */
7375
7376                     }
7377                   break;
7378               }
7379             break;
7380           case 0x10:
7381               GETBYTE ();
7382               switch (op[2] & 0x00)
7383               {
7384                 case 0x00:
7385                   op_semantics_48:
7386                     {
7387                       /** 1111 1100 0001 00ss rsrc rdst max     %1%S1, %0 */
7388 #line 587 "rx-decode.opc"
7389                       int ss AU = op[1] & 0x03;
7390 #line 587 "rx-decode.opc"
7391                       int rsrc AU = (op[2] >> 4) & 0x0f;
7392 #line 587 "rx-decode.opc"
7393                       int rdst AU = op[2] & 0x0f;
7394                       if (trace)
7395                         {
7396                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7397                                  "/** 1111 1100 0001 00ss rsrc rdst     max     %1%S1, %0 */",
7398                                  op[0], op[1], op[2]);
7399                           printf ("  ss = 0x%x,", ss);
7400                           printf ("  rsrc = 0x%x,", rsrc);
7401                           printf ("  rdst = 0x%x\n", rdst);
7402                         }
7403                       SYNTAX("max       %1%S1, %0");
7404 #line 587 "rx-decode.opc"
7405                       if (ss == 3 && rsrc == 0 && rdst == 0)
7406                         {
7407                           ID(nop3);
7408                           SYNTAX("nop\t; max\tr0, r0");
7409                         }
7410                       else
7411                         {
7412                           ID(max); SP(ss, rsrc); DR(rdst);
7413                         }
7414
7415                     }
7416                   break;
7417               }
7418             break;
7419           case 0x11:
7420               GETBYTE ();
7421               switch (op[2] & 0x00)
7422               {
7423                 case 0x00:
7424                   goto op_semantics_48;
7425                   break;
7426               }
7427             break;
7428           case 0x12:
7429               GETBYTE ();
7430               switch (op[2] & 0x00)
7431               {
7432                 case 0x00:
7433                   goto op_semantics_48;
7434                   break;
7435               }
7436             break;
7437           case 0x13:
7438               GETBYTE ();
7439               switch (op[2] & 0x00)
7440               {
7441                 case 0x00:
7442                   goto op_semantics_48;
7443                   break;
7444               }
7445             break;
7446           case 0x14:
7447               GETBYTE ();
7448               switch (op[2] & 0x00)
7449               {
7450                 case 0x00:
7451                   op_semantics_49:
7452                     {
7453                       /** 1111 1100 0001 01ss rsrc rdst min     %1%S1, %0 */
7454 #line 607 "rx-decode.opc"
7455                       int ss AU = op[1] & 0x03;
7456 #line 607 "rx-decode.opc"
7457                       int rsrc AU = (op[2] >> 4) & 0x0f;
7458 #line 607 "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 0001 01ss rsrc rdst     min     %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("min       %1%S1, %0");
7470 #line 607 "rx-decode.opc"
7471                       ID(min); SP(ss, rsrc); DR(rdst);
7472
7473                     }
7474                   break;
7475               }
7476             break;
7477           case 0x15:
7478               GETBYTE ();
7479               switch (op[2] & 0x00)
7480               {
7481                 case 0x00:
7482                   goto op_semantics_49;
7483                   break;
7484               }
7485             break;
7486           case 0x16:
7487               GETBYTE ();
7488               switch (op[2] & 0x00)
7489               {
7490                 case 0x00:
7491                   goto op_semantics_49;
7492                   break;
7493               }
7494             break;
7495           case 0x17:
7496               GETBYTE ();
7497               switch (op[2] & 0x00)
7498               {
7499                 case 0x00:
7500                   goto op_semantics_49;
7501                   break;
7502               }
7503             break;
7504           case 0x18:
7505               GETBYTE ();
7506               switch (op[2] & 0x00)
7507               {
7508                 case 0x00:
7509                   op_semantics_50:
7510                     {
7511                       /** 1111 1100 0001 10ss rsrc rdst emul    %1%S1, %0 */
7512 #line 665 "rx-decode.opc"
7513                       int ss AU = op[1] & 0x03;
7514 #line 665 "rx-decode.opc"
7515                       int rsrc AU = (op[2] >> 4) & 0x0f;
7516 #line 665 "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 0001 10ss rsrc rdst     emul    %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("emul      %1%S1, %0");
7528 #line 665 "rx-decode.opc"
7529                       ID(emul); SP(ss, rsrc); DR(rdst);
7530
7531                     }
7532                   break;
7533               }
7534             break;
7535           case 0x19:
7536               GETBYTE ();
7537               switch (op[2] & 0x00)
7538               {
7539                 case 0x00:
7540                   goto op_semantics_50;
7541                   break;
7542               }
7543             break;
7544           case 0x1a:
7545               GETBYTE ();
7546               switch (op[2] & 0x00)
7547               {
7548                 case 0x00:
7549                   goto op_semantics_50;
7550                   break;
7551               }
7552             break;
7553           case 0x1b:
7554               GETBYTE ();
7555               switch (op[2] & 0x00)
7556               {
7557                 case 0x00:
7558                   goto op_semantics_50;
7559                   break;
7560               }
7561             break;
7562           case 0x1c:
7563               GETBYTE ();
7564               switch (op[2] & 0x00)
7565               {
7566                 case 0x00:
7567                   op_semantics_51:
7568                     {
7569                       /** 1111 1100 0001 11ss rsrc rdst emulu   %1%S1, %0 */
7570 #line 677 "rx-decode.opc"
7571                       int ss AU = op[1] & 0x03;
7572 #line 677 "rx-decode.opc"
7573                       int rsrc AU = (op[2] >> 4) & 0x0f;
7574 #line 677 "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 0001 11ss rsrc rdst     emulu   %1%S1, %0 */",
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("emulu     %1%S1, %0");
7586 #line 677 "rx-decode.opc"
7587                       ID(emulu); SP(ss, rsrc); DR(rdst);
7588
7589                     }
7590                   break;
7591               }
7592             break;
7593           case 0x1d:
7594               GETBYTE ();
7595               switch (op[2] & 0x00)
7596               {
7597                 case 0x00:
7598                   goto op_semantics_51;
7599                   break;
7600               }
7601             break;
7602           case 0x1e:
7603               GETBYTE ();
7604               switch (op[2] & 0x00)
7605               {
7606                 case 0x00:
7607                   goto op_semantics_51;
7608                   break;
7609               }
7610             break;
7611           case 0x1f:
7612               GETBYTE ();
7613               switch (op[2] & 0x00)
7614               {
7615                 case 0x00:
7616                   goto op_semantics_51;
7617                   break;
7618               }
7619             break;
7620           case 0x20:
7621               GETBYTE ();
7622               switch (op[2] & 0x00)
7623               {
7624                 case 0x00:
7625                   op_semantics_52:
7626                     {
7627                       /** 1111 1100 0010 00ss rsrc rdst div     %1%S1, %0 */
7628 #line 689 "rx-decode.opc"
7629                       int ss AU = op[1] & 0x03;
7630 #line 689 "rx-decode.opc"
7631                       int rsrc AU = (op[2] >> 4) & 0x0f;
7632 #line 689 "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 0010 00ss rsrc rdst     div     %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("div       %1%S1, %0");
7644 #line 689 "rx-decode.opc"
7645                       ID(div); SP(ss, rsrc); DR(rdst); F_O___;
7646
7647                     }
7648                   break;
7649               }
7650             break;
7651           case 0x21:
7652               GETBYTE ();
7653               switch (op[2] & 0x00)
7654               {
7655                 case 0x00:
7656                   goto op_semantics_52;
7657                   break;
7658               }
7659             break;
7660           case 0x22:
7661               GETBYTE ();
7662               switch (op[2] & 0x00)
7663               {
7664                 case 0x00:
7665                   goto op_semantics_52;
7666                   break;
7667               }
7668             break;
7669           case 0x23:
7670               GETBYTE ();
7671               switch (op[2] & 0x00)
7672               {
7673                 case 0x00:
7674                   goto op_semantics_52;
7675                   break;
7676               }
7677             break;
7678           case 0x24:
7679               GETBYTE ();
7680               switch (op[2] & 0x00)
7681               {
7682                 case 0x00:
7683                   op_semantics_53:
7684                     {
7685                       /** 1111 1100 0010 01ss rsrc rdst divu    %1%S1, %0 */
7686 #line 701 "rx-decode.opc"
7687                       int ss AU = op[1] & 0x03;
7688 #line 701 "rx-decode.opc"
7689                       int rsrc AU = (op[2] >> 4) & 0x0f;
7690 #line 701 "rx-decode.opc"
7691                       int rdst AU = op[2] & 0x0f;
7692                       if (trace)
7693                         {
7694                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7695                                  "/** 1111 1100 0010 01ss rsrc rdst     divu    %1%S1, %0 */",
7696                                  op[0], op[1], op[2]);
7697                           printf ("  ss = 0x%x,", ss);
7698                           printf ("  rsrc = 0x%x,", rsrc);
7699                           printf ("  rdst = 0x%x\n", rdst);
7700                         }
7701                       SYNTAX("divu      %1%S1, %0");
7702 #line 701 "rx-decode.opc"
7703                       ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
7704
7705                     }
7706                   break;
7707               }
7708             break;
7709           case 0x25:
7710               GETBYTE ();
7711               switch (op[2] & 0x00)
7712               {
7713                 case 0x00:
7714                   goto op_semantics_53;
7715                   break;
7716               }
7717             break;
7718           case 0x26:
7719               GETBYTE ();
7720               switch (op[2] & 0x00)
7721               {
7722                 case 0x00:
7723                   goto op_semantics_53;
7724                   break;
7725               }
7726             break;
7727           case 0x27:
7728               GETBYTE ();
7729               switch (op[2] & 0x00)
7730               {
7731                 case 0x00:
7732                   goto op_semantics_53;
7733                   break;
7734               }
7735             break;
7736           case 0x30:
7737               GETBYTE ();
7738               switch (op[2] & 0x00)
7739               {
7740                 case 0x00:
7741                   op_semantics_54:
7742                     {
7743                       /** 1111 1100 0011 00ss rsrc rdst tst     %1%S1, %2 */
7744 #line 474 "rx-decode.opc"
7745                       int ss AU = op[1] & 0x03;
7746 #line 474 "rx-decode.opc"
7747                       int rsrc AU = (op[2] >> 4) & 0x0f;
7748 #line 474 "rx-decode.opc"
7749                       int rdst AU = op[2] & 0x0f;
7750                       if (trace)
7751                         {
7752                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7753                                  "/** 1111 1100 0011 00ss rsrc rdst     tst     %1%S1, %2 */",
7754                                  op[0], op[1], op[2]);
7755                           printf ("  ss = 0x%x,", ss);
7756                           printf ("  rsrc = 0x%x,", rsrc);
7757                           printf ("  rdst = 0x%x\n", rdst);
7758                         }
7759                       SYNTAX("tst       %1%S1, %2");
7760 #line 474 "rx-decode.opc"
7761                       ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
7762
7763                     }
7764                   break;
7765               }
7766             break;
7767           case 0x31:
7768               GETBYTE ();
7769               switch (op[2] & 0x00)
7770               {
7771                 case 0x00:
7772                   goto op_semantics_54;
7773                   break;
7774               }
7775             break;
7776           case 0x32:
7777               GETBYTE ();
7778               switch (op[2] & 0x00)
7779               {
7780                 case 0x00:
7781                   goto op_semantics_54;
7782                   break;
7783               }
7784             break;
7785           case 0x33:
7786               GETBYTE ();
7787               switch (op[2] & 0x00)
7788               {
7789                 case 0x00:
7790                   goto op_semantics_54;
7791                   break;
7792               }
7793             break;
7794           case 0x34:
7795               GETBYTE ();
7796               switch (op[2] & 0x00)
7797               {
7798                 case 0x00:
7799                   op_semantics_55:
7800                     {
7801                       /** 1111 1100 0011 01ss rsrc rdst xor     %1%S1, %0 */
7802 #line 453 "rx-decode.opc"
7803                       int ss AU = op[1] & 0x03;
7804 #line 453 "rx-decode.opc"
7805                       int rsrc AU = (op[2] >> 4) & 0x0f;
7806 #line 453 "rx-decode.opc"
7807                       int rdst AU = op[2] & 0x0f;
7808                       if (trace)
7809                         {
7810                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7811                                  "/** 1111 1100 0011 01ss rsrc rdst     xor     %1%S1, %0 */",
7812                                  op[0], op[1], op[2]);
7813                           printf ("  ss = 0x%x,", ss);
7814                           printf ("  rsrc = 0x%x,", rsrc);
7815                           printf ("  rdst = 0x%x\n", rdst);
7816                         }
7817                       SYNTAX("xor       %1%S1, %0");
7818 #line 453 "rx-decode.opc"
7819                       ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
7820
7821                     }
7822                   break;
7823               }
7824             break;
7825           case 0x35:
7826               GETBYTE ();
7827               switch (op[2] & 0x00)
7828               {
7829                 case 0x00:
7830                   goto op_semantics_55;
7831                   break;
7832               }
7833             break;
7834           case 0x36:
7835               GETBYTE ();
7836               switch (op[2] & 0x00)
7837               {
7838                 case 0x00:
7839                   goto op_semantics_55;
7840                   break;
7841               }
7842             break;
7843           case 0x37:
7844               GETBYTE ();
7845               switch (op[2] & 0x00)
7846               {
7847                 case 0x00:
7848                   goto op_semantics_55;
7849                   break;
7850               }
7851             break;
7852           case 0x3b:
7853               GETBYTE ();
7854               switch (op[2] & 0x00)
7855               {
7856                 case 0x00:
7857                     {
7858                       /** 1111 1100 0011 1011 rsrc rdst not     %1, %0 */
7859 #line 465 "rx-decode.opc"
7860                       int rsrc AU = (op[2] >> 4) & 0x0f;
7861 #line 465 "rx-decode.opc"
7862                       int rdst AU = op[2] & 0x0f;
7863                       if (trace)
7864                         {
7865                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7866                                  "/** 1111 1100 0011 1011 rsrc rdst     not     %1, %0 */",
7867                                  op[0], op[1], op[2]);
7868                           printf ("  rsrc = 0x%x,", rsrc);
7869                           printf ("  rdst = 0x%x\n", rdst);
7870                         }
7871                       SYNTAX("not       %1, %0");
7872 #line 465 "rx-decode.opc"
7873                       ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
7874
7875                     /*----------------------------------------------------------------------*/
7876                     /* TST                                                                      */
7877
7878                     }
7879                   break;
7880               }
7881             break;
7882           case 0x40:
7883               GETBYTE ();
7884               switch (op[2] & 0x00)
7885               {
7886                 case 0x00:
7887                   op_semantics_56:
7888                     {
7889                       /** 1111 1100 0100 00ss rsrc rdst xchg    %1%S1, %0 */
7890 #line 387 "rx-decode.opc"
7891                       int ss AU = op[1] & 0x03;
7892 #line 387 "rx-decode.opc"
7893                       int rsrc AU = (op[2] >> 4) & 0x0f;
7894 #line 387 "rx-decode.opc"
7895                       int rdst AU = op[2] & 0x0f;
7896                       if (trace)
7897                         {
7898                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7899                                  "/** 1111 1100 0100 00ss rsrc rdst     xchg    %1%S1, %0 */",
7900                                  op[0], op[1], op[2]);
7901                           printf ("  ss = 0x%x,", ss);
7902                           printf ("  rsrc = 0x%x,", rsrc);
7903                           printf ("  rdst = 0x%x\n", rdst);
7904                         }
7905                       SYNTAX("xchg      %1%S1, %0");
7906 #line 387 "rx-decode.opc"
7907                       ID(xchg); DR(rdst); SP(ss, rsrc);
7908
7909                     }
7910                   break;
7911               }
7912             break;
7913           case 0x41:
7914               GETBYTE ();
7915               switch (op[2] & 0x00)
7916               {
7917                 case 0x00:
7918                   goto op_semantics_56;
7919                   break;
7920               }
7921             break;
7922           case 0x42:
7923               GETBYTE ();
7924               switch (op[2] & 0x00)
7925               {
7926                 case 0x00:
7927                   goto op_semantics_56;
7928                   break;
7929               }
7930             break;
7931           case 0x43:
7932               GETBYTE ();
7933               switch (op[2] & 0x00)
7934               {
7935                 case 0x00:
7936                   goto op_semantics_56;
7937                   break;
7938               }
7939             break;
7940           case 0x44:
7941               GETBYTE ();
7942               switch (op[2] & 0x00)
7943               {
7944                 case 0x00:
7945                   op_semantics_57:
7946                     {
7947                       /** 1111 1100 0100 01sd rsrc rdst itof    %1%S1, %0 */
7948 #line 930 "rx-decode.opc"
7949                       int sd AU = op[1] & 0x03;
7950 #line 930 "rx-decode.opc"
7951                       int rsrc AU = (op[2] >> 4) & 0x0f;
7952 #line 930 "rx-decode.opc"
7953                       int rdst AU = op[2] & 0x0f;
7954                       if (trace)
7955                         {
7956                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7957                                  "/** 1111 1100 0100 01sd rsrc rdst     itof    %1%S1, %0 */",
7958                                  op[0], op[1], op[2]);
7959                           printf ("  sd = 0x%x,", sd);
7960                           printf ("  rsrc = 0x%x,", rsrc);
7961                           printf ("  rdst = 0x%x\n", rdst);
7962                         }
7963                       SYNTAX("itof      %1%S1, %0");
7964 #line 930 "rx-decode.opc"
7965                       ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
7966
7967                     }
7968                   break;
7969               }
7970             break;
7971           case 0x45:
7972               GETBYTE ();
7973               switch (op[2] & 0x00)
7974               {
7975                 case 0x00:
7976                   goto op_semantics_57;
7977                   break;
7978               }
7979             break;
7980           case 0x46:
7981               GETBYTE ();
7982               switch (op[2] & 0x00)
7983               {
7984                 case 0x00:
7985                   goto op_semantics_57;
7986                   break;
7987               }
7988             break;
7989           case 0x47:
7990               GETBYTE ();
7991               switch (op[2] & 0x00)
7992               {
7993                 case 0x00:
7994                   goto op_semantics_57;
7995                   break;
7996               }
7997             break;
7998           case 0x4b:
7999               GETBYTE ();
8000               switch (op[2] & 0x00)
8001               {
8002                 case 0x00:
8003                     {
8004                       /** 1111 1100 0100 1011 rsrc rdst stz     %1, %0 */
8005 #line 1056 "rx-decode.opc"
8006                       int rsrc AU = (op[2] >> 4) & 0x0f;
8007 #line 1056 "rx-decode.opc"
8008                       int rdst AU = op[2] & 0x0f;
8009                       if (trace)
8010                         {
8011                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8012                                  "/** 1111 1100 0100 1011 rsrc rdst     stz     %1, %0 */",
8013                                  op[0], op[1], op[2]);
8014                           printf ("  rsrc = 0x%x,", rsrc);
8015                           printf ("  rdst = 0x%x\n", rdst);
8016                         }
8017                       SYNTAX("stz       %1, %0");
8018 #line 1056 "rx-decode.opc"
8019                       ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
8020
8021                     }
8022                   break;
8023               }
8024             break;
8025           case 0x4f:
8026               GETBYTE ();
8027               switch (op[2] & 0x00)
8028               {
8029                 case 0x00:
8030                     {
8031                       /** 1111 1100 0100 1111 rsrc rdst stnz    %1, %0 */
8032 #line 1059 "rx-decode.opc"
8033                       int rsrc AU = (op[2] >> 4) & 0x0f;
8034 #line 1059 "rx-decode.opc"
8035                       int rdst AU = op[2] & 0x0f;
8036                       if (trace)
8037                         {
8038                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8039                                  "/** 1111 1100 0100 1111 rsrc rdst     stnz    %1, %0 */",
8040                                  op[0], op[1], op[2]);
8041                           printf ("  rsrc = 0x%x,", rsrc);
8042                           printf ("  rdst = 0x%x\n", rdst);
8043                         }
8044                       SYNTAX("stnz      %1, %0");
8045 #line 1059 "rx-decode.opc"
8046                       ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
8047
8048                     }
8049                   break;
8050               }
8051             break;
8052           case 0x54:
8053               GETBYTE ();
8054               switch (op[2] & 0x00)
8055               {
8056                 case 0x00:
8057                   op_semantics_58:
8058                     {
8059                       /** 1111 1100 0101 01sd rsrc rdst utof    %1%S1, %0 */
8060 #line 1116 "rx-decode.opc"
8061                       int sd AU = op[1] & 0x03;
8062 #line 1116 "rx-decode.opc"
8063                       int rsrc AU = (op[2] >> 4) & 0x0f;
8064 #line 1116 "rx-decode.opc"
8065                       int rdst AU = op[2] & 0x0f;
8066                       if (trace)
8067                         {
8068                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8069                                  "/** 1111 1100 0101 01sd rsrc rdst     utof    %1%S1, %0 */",
8070                                  op[0], op[1], op[2]);
8071                           printf ("  sd = 0x%x,", sd);
8072                           printf ("  rsrc = 0x%x,", rsrc);
8073                           printf ("  rdst = 0x%x\n", rdst);
8074                         }
8075                       SYNTAX("utof      %1%S1, %0");
8076 #line 1116 "rx-decode.opc"
8077                       ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
8078
8079                     }
8080                   break;
8081               }
8082             break;
8083           case 0x55:
8084               GETBYTE ();
8085               switch (op[2] & 0x00)
8086               {
8087                 case 0x00:
8088                   goto op_semantics_58;
8089                   break;
8090               }
8091             break;
8092           case 0x56:
8093               GETBYTE ();
8094               switch (op[2] & 0x00)
8095               {
8096                 case 0x00:
8097                   goto op_semantics_58;
8098                   break;
8099               }
8100             break;
8101           case 0x57:
8102               GETBYTE ();
8103               switch (op[2] & 0x00)
8104               {
8105                 case 0x00:
8106                   goto op_semantics_58;
8107                   break;
8108               }
8109             break;
8110           case 0x60:
8111               GETBYTE ();
8112               switch (op[2] & 0x00)
8113               {
8114                 case 0x00:
8115                   op_semantics_59:
8116                     {
8117                       /** 1111 1100 0110 00sd rdst rsrc bset    %1, %0%S0 */
8118 #line 942 "rx-decode.opc"
8119                       int sd AU = op[1] & 0x03;
8120 #line 942 "rx-decode.opc"
8121                       int rdst AU = (op[2] >> 4) & 0x0f;
8122 #line 942 "rx-decode.opc"
8123                       int rsrc AU = op[2] & 0x0f;
8124                       if (trace)
8125                         {
8126                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8127                                  "/** 1111 1100 0110 00sd rdst rsrc     bset    %1, %0%S0 */",
8128                                  op[0], op[1], op[2]);
8129                           printf ("  sd = 0x%x,", sd);
8130                           printf ("  rdst = 0x%x,", rdst);
8131                           printf ("  rsrc = 0x%x\n", rsrc);
8132                         }
8133                       SYNTAX("bset      %1, %0%S0");
8134 #line 942 "rx-decode.opc"
8135                       ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8136                       if (sd == 3) /* bset reg,reg */
8137                         BWL(LSIZE);
8138
8139                     }
8140                   break;
8141               }
8142             break;
8143           case 0x61:
8144               GETBYTE ();
8145               switch (op[2] & 0x00)
8146               {
8147                 case 0x00:
8148                   goto op_semantics_59;
8149                   break;
8150               }
8151             break;
8152           case 0x62:
8153               GETBYTE ();
8154               switch (op[2] & 0x00)
8155               {
8156                 case 0x00:
8157                   goto op_semantics_59;
8158                   break;
8159               }
8160             break;
8161           case 0x63:
8162               GETBYTE ();
8163               switch (op[2] & 0x00)
8164               {
8165                 case 0x00:
8166                   goto op_semantics_59;
8167                   break;
8168               }
8169             break;
8170           case 0x64:
8171               GETBYTE ();
8172               switch (op[2] & 0x00)
8173               {
8174                 case 0x00:
8175                   op_semantics_60:
8176                     {
8177                       /** 1111 1100 0110 01sd rdst rsrc bclr    %1, %0%S0 */
8178 #line 954 "rx-decode.opc"
8179                       int sd AU = op[1] & 0x03;
8180 #line 954 "rx-decode.opc"
8181                       int rdst AU = (op[2] >> 4) & 0x0f;
8182 #line 954 "rx-decode.opc"
8183                       int rsrc AU = op[2] & 0x0f;
8184                       if (trace)
8185                         {
8186                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8187                                  "/** 1111 1100 0110 01sd rdst rsrc     bclr    %1, %0%S0 */",
8188                                  op[0], op[1], op[2]);
8189                           printf ("  sd = 0x%x,", sd);
8190                           printf ("  rdst = 0x%x,", rdst);
8191                           printf ("  rsrc = 0x%x\n", rsrc);
8192                         }
8193                       SYNTAX("bclr      %1, %0%S0");
8194 #line 954 "rx-decode.opc"
8195                       ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8196                       if (sd == 3) /* bset reg,reg */
8197                         BWL(LSIZE);
8198
8199                     }
8200                   break;
8201               }
8202             break;
8203           case 0x65:
8204               GETBYTE ();
8205               switch (op[2] & 0x00)
8206               {
8207                 case 0x00:
8208                   goto op_semantics_60;
8209                   break;
8210               }
8211             break;
8212           case 0x66:
8213               GETBYTE ();
8214               switch (op[2] & 0x00)
8215               {
8216                 case 0x00:
8217                   goto op_semantics_60;
8218                   break;
8219               }
8220             break;
8221           case 0x67:
8222               GETBYTE ();
8223               switch (op[2] & 0x00)
8224               {
8225                 case 0x00:
8226                   goto op_semantics_60;
8227                   break;
8228               }
8229             break;
8230           case 0x68:
8231               GETBYTE ();
8232               switch (op[2] & 0x00)
8233               {
8234                 case 0x00:
8235                   op_semantics_61:
8236                     {
8237                       /** 1111 1100 0110 10sd rdst rsrc btst    %2, %1%S1 */
8238 #line 966 "rx-decode.opc"
8239                       int sd AU = op[1] & 0x03;
8240 #line 966 "rx-decode.opc"
8241                       int rdst AU = (op[2] >> 4) & 0x0f;
8242 #line 966 "rx-decode.opc"
8243                       int rsrc AU = op[2] & 0x0f;
8244                       if (trace)
8245                         {
8246                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8247                                  "/** 1111 1100 0110 10sd rdst rsrc     btst    %2, %1%S1 */",
8248                                  op[0], op[1], op[2]);
8249                           printf ("  sd = 0x%x,", sd);
8250                           printf ("  rdst = 0x%x,", rdst);
8251                           printf ("  rsrc = 0x%x\n", rsrc);
8252                         }
8253                       SYNTAX("btst      %2, %1%S1");
8254 #line 966 "rx-decode.opc"
8255                       ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
8256                       if (sd == 3) /* bset reg,reg */
8257                         BWL(LSIZE);
8258
8259                     }
8260                   break;
8261               }
8262             break;
8263           case 0x69:
8264               GETBYTE ();
8265               switch (op[2] & 0x00)
8266               {
8267                 case 0x00:
8268                   goto op_semantics_61;
8269                   break;
8270               }
8271             break;
8272           case 0x6a:
8273               GETBYTE ();
8274               switch (op[2] & 0x00)
8275               {
8276                 case 0x00:
8277                   goto op_semantics_61;
8278                   break;
8279               }
8280             break;
8281           case 0x6b:
8282               GETBYTE ();
8283               switch (op[2] & 0x00)
8284               {
8285                 case 0x00:
8286                   goto op_semantics_61;
8287                   break;
8288               }
8289             break;
8290           case 0x6c:
8291               GETBYTE ();
8292               switch (op[2] & 0x00)
8293               {
8294                 case 0x00:
8295                   op_semantics_62:
8296                     {
8297                       /** 1111 1100 0110 11sd rdst rsrc bnot    %1, %0%S0 */
8298 #line 978 "rx-decode.opc"
8299                       int sd AU = op[1] & 0x03;
8300 #line 978 "rx-decode.opc"
8301                       int rdst AU = (op[2] >> 4) & 0x0f;
8302 #line 978 "rx-decode.opc"
8303                       int rsrc AU = op[2] & 0x0f;
8304                       if (trace)
8305                         {
8306                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8307                                  "/** 1111 1100 0110 11sd rdst rsrc     bnot    %1, %0%S0 */",
8308                                  op[0], op[1], op[2]);
8309                           printf ("  sd = 0x%x,", sd);
8310                           printf ("  rdst = 0x%x,", rdst);
8311                           printf ("  rsrc = 0x%x\n", rsrc);
8312                         }
8313                       SYNTAX("bnot      %1, %0%S0");
8314 #line 978 "rx-decode.opc"
8315                       ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
8316                       if (sd == 3) /* bset reg,reg */
8317                         BWL(LSIZE);
8318
8319                     }
8320                   break;
8321               }
8322             break;
8323           case 0x6d:
8324               GETBYTE ();
8325               switch (op[2] & 0x00)
8326               {
8327                 case 0x00:
8328                   goto op_semantics_62;
8329                   break;
8330               }
8331             break;
8332           case 0x6e:
8333               GETBYTE ();
8334               switch (op[2] & 0x00)
8335               {
8336                 case 0x00:
8337                   goto op_semantics_62;
8338                   break;
8339               }
8340             break;
8341           case 0x6f:
8342               GETBYTE ();
8343               switch (op[2] & 0x00)
8344               {
8345                 case 0x00:
8346                   goto op_semantics_62;
8347                   break;
8348               }
8349             break;
8350           case 0x80:
8351               GETBYTE ();
8352               switch (op[2] & 0x00)
8353               {
8354                 case 0x00:
8355                   op_semantics_63:
8356                     {
8357                       /** 1111 1100 1000 00sd rsrc rdst fsub    %1%S1, %0 */
8358 #line 909 "rx-decode.opc"
8359                       int sd AU = op[1] & 0x03;
8360 #line 909 "rx-decode.opc"
8361                       int rsrc AU = (op[2] >> 4) & 0x0f;
8362 #line 909 "rx-decode.opc"
8363                       int rdst AU = op[2] & 0x0f;
8364                       if (trace)
8365                         {
8366                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8367                                  "/** 1111 1100 1000 00sd rsrc rdst     fsub    %1%S1, %0 */",
8368                                  op[0], op[1], op[2]);
8369                           printf ("  sd = 0x%x,", sd);
8370                           printf ("  rsrc = 0x%x,", rsrc);
8371                           printf ("  rdst = 0x%x\n", rdst);
8372                         }
8373                       SYNTAX("fsub      %1%S1, %0");
8374 #line 909 "rx-decode.opc"
8375                       ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8376
8377                     }
8378                   break;
8379               }
8380             break;
8381           case 0x81:
8382               GETBYTE ();
8383               switch (op[2] & 0x00)
8384               {
8385                 case 0x00:
8386                   goto op_semantics_63;
8387                   break;
8388               }
8389             break;
8390           case 0x82:
8391               GETBYTE ();
8392               switch (op[2] & 0x00)
8393               {
8394                 case 0x00:
8395                   goto op_semantics_63;
8396                   break;
8397               }
8398             break;
8399           case 0x83:
8400               GETBYTE ();
8401               switch (op[2] & 0x00)
8402               {
8403                 case 0x00:
8404                   goto op_semantics_63;
8405                   break;
8406               }
8407             break;
8408           case 0x84:
8409               GETBYTE ();
8410               switch (op[2] & 0x00)
8411               {
8412                 case 0x00:
8413                   op_semantics_64:
8414                     {
8415                       /** 1111 1100 1000 01sd rsrc rdst fcmp    %1%S1, %0 */
8416 #line 903 "rx-decode.opc"
8417                       int sd AU = op[1] & 0x03;
8418 #line 903 "rx-decode.opc"
8419                       int rsrc AU = (op[2] >> 4) & 0x0f;
8420 #line 903 "rx-decode.opc"
8421                       int rdst AU = op[2] & 0x0f;
8422                       if (trace)
8423                         {
8424                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8425                                  "/** 1111 1100 1000 01sd rsrc rdst     fcmp    %1%S1, %0 */",
8426                                  op[0], op[1], op[2]);
8427                           printf ("  sd = 0x%x,", sd);
8428                           printf ("  rsrc = 0x%x,", rsrc);
8429                           printf ("  rdst = 0x%x\n", rdst);
8430                         }
8431                       SYNTAX("fcmp      %1%S1, %0");
8432 #line 903 "rx-decode.opc"
8433                       ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
8434
8435                     }
8436                   break;
8437               }
8438             break;
8439           case 0x85:
8440               GETBYTE ();
8441               switch (op[2] & 0x00)
8442               {
8443                 case 0x00:
8444                   goto op_semantics_64;
8445                   break;
8446               }
8447             break;
8448           case 0x86:
8449               GETBYTE ();
8450               switch (op[2] & 0x00)
8451               {
8452                 case 0x00:
8453                   goto op_semantics_64;
8454                   break;
8455               }
8456             break;
8457           case 0x87:
8458               GETBYTE ();
8459               switch (op[2] & 0x00)
8460               {
8461                 case 0x00:
8462                   goto op_semantics_64;
8463                   break;
8464               }
8465             break;
8466           case 0x88:
8467               GETBYTE ();
8468               switch (op[2] & 0x00)
8469               {
8470                 case 0x00:
8471                   op_semantics_65:
8472                     {
8473                       /** 1111 1100 1000 10sd rsrc rdst fadd    %1%S1, %0 */
8474 #line 897 "rx-decode.opc"
8475                       int sd AU = op[1] & 0x03;
8476 #line 897 "rx-decode.opc"
8477                       int rsrc AU = (op[2] >> 4) & 0x0f;
8478 #line 897 "rx-decode.opc"
8479                       int rdst AU = op[2] & 0x0f;
8480                       if (trace)
8481                         {
8482                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8483                                  "/** 1111 1100 1000 10sd rsrc rdst     fadd    %1%S1, %0 */",
8484                                  op[0], op[1], op[2]);
8485                           printf ("  sd = 0x%x,", sd);
8486                           printf ("  rsrc = 0x%x,", rsrc);
8487                           printf ("  rdst = 0x%x\n", rdst);
8488                         }
8489                       SYNTAX("fadd      %1%S1, %0");
8490 #line 897 "rx-decode.opc"
8491                       ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8492
8493                     }
8494                   break;
8495               }
8496             break;
8497           case 0x89:
8498               GETBYTE ();
8499               switch (op[2] & 0x00)
8500               {
8501                 case 0x00:
8502                   goto op_semantics_65;
8503                   break;
8504               }
8505             break;
8506           case 0x8a:
8507               GETBYTE ();
8508               switch (op[2] & 0x00)
8509               {
8510                 case 0x00:
8511                   goto op_semantics_65;
8512                   break;
8513               }
8514             break;
8515           case 0x8b:
8516               GETBYTE ();
8517               switch (op[2] & 0x00)
8518               {
8519                 case 0x00:
8520                   goto op_semantics_65;
8521                   break;
8522               }
8523             break;
8524           case 0x8c:
8525               GETBYTE ();
8526               switch (op[2] & 0x00)
8527               {
8528                 case 0x00:
8529                   op_semantics_66:
8530                     {
8531                       /** 1111 1100 1000 11sd rsrc rdst fmul    %1%S1, %0 */
8532 #line 918 "rx-decode.opc"
8533                       int sd AU = op[1] & 0x03;
8534 #line 918 "rx-decode.opc"
8535                       int rsrc AU = (op[2] >> 4) & 0x0f;
8536 #line 918 "rx-decode.opc"
8537                       int rdst AU = op[2] & 0x0f;
8538                       if (trace)
8539                         {
8540                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8541                                  "/** 1111 1100 1000 11sd rsrc rdst     fmul    %1%S1, %0 */",
8542                                  op[0], op[1], op[2]);
8543                           printf ("  sd = 0x%x,", sd);
8544                           printf ("  rsrc = 0x%x,", rsrc);
8545                           printf ("  rdst = 0x%x\n", rdst);
8546                         }
8547                       SYNTAX("fmul      %1%S1, %0");
8548 #line 918 "rx-decode.opc"
8549                       ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8550
8551                     }
8552                   break;
8553               }
8554             break;
8555           case 0x8d:
8556               GETBYTE ();
8557               switch (op[2] & 0x00)
8558               {
8559                 case 0x00:
8560                   goto op_semantics_66;
8561                   break;
8562               }
8563             break;
8564           case 0x8e:
8565               GETBYTE ();
8566               switch (op[2] & 0x00)
8567               {
8568                 case 0x00:
8569                   goto op_semantics_66;
8570                   break;
8571               }
8572             break;
8573           case 0x8f:
8574               GETBYTE ();
8575               switch (op[2] & 0x00)
8576               {
8577                 case 0x00:
8578                   goto op_semantics_66;
8579                   break;
8580               }
8581             break;
8582           case 0x90:
8583               GETBYTE ();
8584               switch (op[2] & 0x00)
8585               {
8586                 case 0x00:
8587                   op_semantics_67:
8588                     {
8589                       /** 1111 1100 1001 00sd rsrc rdst fdiv    %1%S1, %0 */
8590 #line 924 "rx-decode.opc"
8591                       int sd AU = op[1] & 0x03;
8592 #line 924 "rx-decode.opc"
8593                       int rsrc AU = (op[2] >> 4) & 0x0f;
8594 #line 924 "rx-decode.opc"
8595                       int rdst AU = op[2] & 0x0f;
8596                       if (trace)
8597                         {
8598                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8599                                  "/** 1111 1100 1001 00sd rsrc rdst     fdiv    %1%S1, %0 */",
8600                                  op[0], op[1], op[2]);
8601                           printf ("  sd = 0x%x,", sd);
8602                           printf ("  rsrc = 0x%x,", rsrc);
8603                           printf ("  rdst = 0x%x\n", rdst);
8604                         }
8605                       SYNTAX("fdiv      %1%S1, %0");
8606 #line 924 "rx-decode.opc"
8607                       ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8608
8609                     }
8610                   break;
8611               }
8612             break;
8613           case 0x91:
8614               GETBYTE ();
8615               switch (op[2] & 0x00)
8616               {
8617                 case 0x00:
8618                   goto op_semantics_67;
8619                   break;
8620               }
8621             break;
8622           case 0x92:
8623               GETBYTE ();
8624               switch (op[2] & 0x00)
8625               {
8626                 case 0x00:
8627                   goto op_semantics_67;
8628                   break;
8629               }
8630             break;
8631           case 0x93:
8632               GETBYTE ();
8633               switch (op[2] & 0x00)
8634               {
8635                 case 0x00:
8636                   goto op_semantics_67;
8637                   break;
8638               }
8639             break;
8640           case 0x94:
8641               GETBYTE ();
8642               switch (op[2] & 0x00)
8643               {
8644                 case 0x00:
8645                   op_semantics_68:
8646                     {
8647                       /** 1111 1100 1001 01sd rsrc rdst ftoi    %1%S1, %0 */
8648 #line 912 "rx-decode.opc"
8649                       int sd AU = op[1] & 0x03;
8650 #line 912 "rx-decode.opc"
8651                       int rsrc AU = (op[2] >> 4) & 0x0f;
8652 #line 912 "rx-decode.opc"
8653                       int rdst AU = op[2] & 0x0f;
8654                       if (trace)
8655                         {
8656                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8657                                  "/** 1111 1100 1001 01sd rsrc rdst     ftoi    %1%S1, %0 */",
8658                                  op[0], op[1], op[2]);
8659                           printf ("  sd = 0x%x,", sd);
8660                           printf ("  rsrc = 0x%x,", rsrc);
8661                           printf ("  rdst = 0x%x\n", rdst);
8662                         }
8663                       SYNTAX("ftoi      %1%S1, %0");
8664 #line 912 "rx-decode.opc"
8665                       ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8666
8667                     }
8668                   break;
8669               }
8670             break;
8671           case 0x95:
8672               GETBYTE ();
8673               switch (op[2] & 0x00)
8674               {
8675                 case 0x00:
8676                   goto op_semantics_68;
8677                   break;
8678               }
8679             break;
8680           case 0x96:
8681               GETBYTE ();
8682               switch (op[2] & 0x00)
8683               {
8684                 case 0x00:
8685                   goto op_semantics_68;
8686                   break;
8687               }
8688             break;
8689           case 0x97:
8690               GETBYTE ();
8691               switch (op[2] & 0x00)
8692               {
8693                 case 0x00:
8694                   goto op_semantics_68;
8695                   break;
8696               }
8697             break;
8698           case 0x98:
8699               GETBYTE ();
8700               switch (op[2] & 0x00)
8701               {
8702                 case 0x00:
8703                   op_semantics_69:
8704                     {
8705                       /** 1111 1100 1001 10sd rsrc rdst round   %1%S1, %0 */
8706 #line 927 "rx-decode.opc"
8707                       int sd AU = op[1] & 0x03;
8708 #line 927 "rx-decode.opc"
8709                       int rsrc AU = (op[2] >> 4) & 0x0f;
8710 #line 927 "rx-decode.opc"
8711                       int rdst AU = op[2] & 0x0f;
8712                       if (trace)
8713                         {
8714                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8715                                  "/** 1111 1100 1001 10sd rsrc rdst     round   %1%S1, %0 */",
8716                                  op[0], op[1], op[2]);
8717                           printf ("  sd = 0x%x,", sd);
8718                           printf ("  rsrc = 0x%x,", rsrc);
8719                           printf ("  rdst = 0x%x\n", rdst);
8720                         }
8721                       SYNTAX("round     %1%S1, %0");
8722 #line 927 "rx-decode.opc"
8723                       ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8724
8725                     }
8726                   break;
8727               }
8728             break;
8729           case 0x99:
8730               GETBYTE ();
8731               switch (op[2] & 0x00)
8732               {
8733                 case 0x00:
8734                   goto op_semantics_69;
8735                   break;
8736               }
8737             break;
8738           case 0x9a:
8739               GETBYTE ();
8740               switch (op[2] & 0x00)
8741               {
8742                 case 0x00:
8743                   goto op_semantics_69;
8744                   break;
8745               }
8746             break;
8747           case 0x9b:
8748               GETBYTE ();
8749               switch (op[2] & 0x00)
8750               {
8751                 case 0x00:
8752                   goto op_semantics_69;
8753                   break;
8754               }
8755             break;
8756           case 0xa0:
8757               GETBYTE ();
8758               switch (op[2] & 0x00)
8759               {
8760                 case 0x00:
8761                   op_semantics_70:
8762                     {
8763                       /** 1111 1100 1010 00sd rsrc rdst fsqrt   %1%S1, %0 */
8764 #line 1110 "rx-decode.opc"
8765                       int sd AU = op[1] & 0x03;
8766 #line 1110 "rx-decode.opc"
8767                       int rsrc AU = (op[2] >> 4) & 0x0f;
8768 #line 1110 "rx-decode.opc"
8769                       int rdst AU = op[2] & 0x0f;
8770                       if (trace)
8771                         {
8772                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8773                                  "/** 1111 1100 1010 00sd rsrc rdst     fsqrt   %1%S1, %0 */",
8774                                  op[0], op[1], op[2]);
8775                           printf ("  sd = 0x%x,", sd);
8776                           printf ("  rsrc = 0x%x,", rsrc);
8777                           printf ("  rdst = 0x%x\n", rdst);
8778                         }
8779                       SYNTAX("fsqrt     %1%S1, %0");
8780 #line 1110 "rx-decode.opc"
8781                       ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8782
8783                     }
8784                   break;
8785               }
8786             break;
8787           case 0xa1:
8788               GETBYTE ();
8789               switch (op[2] & 0x00)
8790               {
8791                 case 0x00:
8792                   goto op_semantics_70;
8793                   break;
8794               }
8795             break;
8796           case 0xa2:
8797               GETBYTE ();
8798               switch (op[2] & 0x00)
8799               {
8800                 case 0x00:
8801                   goto op_semantics_70;
8802                   break;
8803               }
8804             break;
8805           case 0xa3:
8806               GETBYTE ();
8807               switch (op[2] & 0x00)
8808               {
8809                 case 0x00:
8810                   goto op_semantics_70;
8811                   break;
8812               }
8813             break;
8814           case 0xa4:
8815               GETBYTE ();
8816               switch (op[2] & 0x00)
8817               {
8818                 case 0x00:
8819                   op_semantics_71:
8820                     {
8821                       /** 1111 1100 1010 01sd rsrc rdst ftou    %1%S1, %0 */
8822 #line 1113 "rx-decode.opc"
8823                       int sd AU = op[1] & 0x03;
8824 #line 1113 "rx-decode.opc"
8825                       int rsrc AU = (op[2] >> 4) & 0x0f;
8826 #line 1113 "rx-decode.opc"
8827                       int rdst AU = op[2] & 0x0f;
8828                       if (trace)
8829                         {
8830                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8831                                  "/** 1111 1100 1010 01sd rsrc rdst     ftou    %1%S1, %0 */",
8832                                  op[0], op[1], op[2]);
8833                           printf ("  sd = 0x%x,", sd);
8834                           printf ("  rsrc = 0x%x,", rsrc);
8835                           printf ("  rdst = 0x%x\n", rdst);
8836                         }
8837                       SYNTAX("ftou      %1%S1, %0");
8838 #line 1113 "rx-decode.opc"
8839                       ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8840
8841                     }
8842                   break;
8843               }
8844             break;
8845           case 0xa5:
8846               GETBYTE ();
8847               switch (op[2] & 0x00)
8848               {
8849                 case 0x00:
8850                   goto op_semantics_71;
8851                   break;
8852               }
8853             break;
8854           case 0xa6:
8855               GETBYTE ();
8856               switch (op[2] & 0x00)
8857               {
8858                 case 0x00:
8859                   goto op_semantics_71;
8860                   break;
8861               }
8862             break;
8863           case 0xa7:
8864               GETBYTE ();
8865               switch (op[2] & 0x00)
8866               {
8867                 case 0x00:
8868                   goto op_semantics_71;
8869                   break;
8870               }
8871             break;
8872           case 0xd0:
8873               GETBYTE ();
8874               switch (op[2] & 0x00)
8875               {
8876                 case 0x00:
8877                   op_semantics_72:
8878                     {
8879                       /** 1111 1100 1101 sz sd rdst cond        sc%1%s  %0 */
8880 #line 1044 "rx-decode.opc"
8881                       int sz AU = (op[1] >> 2) & 0x03;
8882 #line 1044 "rx-decode.opc"
8883                       int sd AU = op[1] & 0x03;
8884 #line 1044 "rx-decode.opc"
8885                       int rdst AU = (op[2] >> 4) & 0x0f;
8886 #line 1044 "rx-decode.opc"
8887                       int cond AU = op[2] & 0x0f;
8888                       if (trace)
8889                         {
8890                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8891                                  "/** 1111 1100 1101 sz sd rdst cond    sc%1%s  %0 */",
8892                                  op[0], op[1], op[2]);
8893                           printf ("  sz = 0x%x,", sz);
8894                           printf ("  sd = 0x%x,", sd);
8895                           printf ("  rdst = 0x%x,", rdst);
8896                           printf ("  cond = 0x%x\n", cond);
8897                         }
8898                       SYNTAX("sc%1%s    %0");
8899 #line 1044 "rx-decode.opc"
8900                       ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8901
8902                     /*----------------------------------------------------------------------*/
8903                     /* RXv2 enhanced                                                            */
8904
8905                     }
8906                   break;
8907               }
8908             break;
8909           case 0xd1:
8910               GETBYTE ();
8911               switch (op[2] & 0x00)
8912               {
8913                 case 0x00:
8914                   goto op_semantics_72;
8915                   break;
8916               }
8917             break;
8918           case 0xd2:
8919               GETBYTE ();
8920               switch (op[2] & 0x00)
8921               {
8922                 case 0x00:
8923                   goto op_semantics_72;
8924                   break;
8925               }
8926             break;
8927           case 0xd3:
8928               GETBYTE ();
8929               switch (op[2] & 0x00)
8930               {
8931                 case 0x00:
8932                   goto op_semantics_72;
8933                   break;
8934               }
8935             break;
8936           case 0xd4:
8937               GETBYTE ();
8938               switch (op[2] & 0x00)
8939               {
8940                 case 0x00:
8941                   goto op_semantics_72;
8942                   break;
8943               }
8944             break;
8945           case 0xd5:
8946               GETBYTE ();
8947               switch (op[2] & 0x00)
8948               {
8949                 case 0x00:
8950                   goto op_semantics_72;
8951                   break;
8952               }
8953             break;
8954           case 0xd6:
8955               GETBYTE ();
8956               switch (op[2] & 0x00)
8957               {
8958                 case 0x00:
8959                   goto op_semantics_72;
8960                   break;
8961               }
8962             break;
8963           case 0xd7:
8964               GETBYTE ();
8965               switch (op[2] & 0x00)
8966               {
8967                 case 0x00:
8968                   goto op_semantics_72;
8969                   break;
8970               }
8971             break;
8972           case 0xd8:
8973               GETBYTE ();
8974               switch (op[2] & 0x00)
8975               {
8976                 case 0x00:
8977                   goto op_semantics_72;
8978                   break;
8979               }
8980             break;
8981           case 0xd9:
8982               GETBYTE ();
8983               switch (op[2] & 0x00)
8984               {
8985                 case 0x00:
8986                   goto op_semantics_72;
8987                   break;
8988               }
8989             break;
8990           case 0xda:
8991               GETBYTE ();
8992               switch (op[2] & 0x00)
8993               {
8994                 case 0x00:
8995                   goto op_semantics_72;
8996                   break;
8997               }
8998             break;
8999           case 0xdb:
9000               GETBYTE ();
9001               switch (op[2] & 0x00)
9002               {
9003                 case 0x00:
9004                   goto op_semantics_72;
9005                   break;
9006               }
9007             break;
9008           case 0xe0:
9009               GETBYTE ();
9010               switch (op[2] & 0x0f)
9011               {
9012                 case 0x00:
9013                 case 0x01:
9014                 case 0x02:
9015                 case 0x03:
9016                 case 0x04:
9017                 case 0x05:
9018                 case 0x06:
9019                 case 0x07:
9020                 case 0x08:
9021                 case 0x09:
9022                 case 0x0a:
9023                 case 0x0b:
9024                 case 0x0c:
9025                 case 0x0d:
9026                 case 0x0e:
9027                   op_semantics_73:
9028                     {
9029                       /** 1111 1100 111bit sd rdst cond bm%2    #%1, %0%S0 */
9030 #line 987 "rx-decode.opc"
9031                       int bit AU = (op[1] >> 2) & 0x07;
9032 #line 987 "rx-decode.opc"
9033                       int sd AU = op[1] & 0x03;
9034 #line 987 "rx-decode.opc"
9035                       int rdst AU = (op[2] >> 4) & 0x0f;
9036 #line 987 "rx-decode.opc"
9037                       int cond AU = op[2] & 0x0f;
9038                       if (trace)
9039                         {
9040                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9041                                  "/** 1111 1100 111bit sd rdst cond     bm%2    #%1, %0%S0 */",
9042                                  op[0], op[1], op[2]);
9043                           printf ("  bit = 0x%x,", bit);
9044                           printf ("  sd = 0x%x,", sd);
9045                           printf ("  rdst = 0x%x,", rdst);
9046                           printf ("  cond = 0x%x\n", cond);
9047                         }
9048                       SYNTAX("bm%2      #%1, %0%S0");
9049 #line 987 "rx-decode.opc"
9050                       ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
9051
9052                     }
9053                   break;
9054                 case 0x0f:
9055                   op_semantics_74:
9056                     {
9057                       /** 1111 1100 111bit sd rdst 1111 bnot    #%1, %0%S0 */
9058 #line 975 "rx-decode.opc"
9059                       int bit AU = (op[1] >> 2) & 0x07;
9060 #line 975 "rx-decode.opc"
9061                       int sd AU = op[1] & 0x03;
9062 #line 975 "rx-decode.opc"
9063                       int rdst AU = (op[2] >> 4) & 0x0f;
9064                       if (trace)
9065                         {
9066                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9067                                  "/** 1111 1100 111bit sd rdst 1111     bnot    #%1, %0%S0 */",
9068                                  op[0], op[1], op[2]);
9069                           printf ("  bit = 0x%x,", bit);
9070                           printf ("  sd = 0x%x,", sd);
9071                           printf ("  rdst = 0x%x\n", rdst);
9072                         }
9073                       SYNTAX("bnot      #%1, %0%S0");
9074 #line 975 "rx-decode.opc"
9075                       ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
9076
9077                     }
9078                   break;
9079               }
9080             break;
9081           case 0xe1:
9082               GETBYTE ();
9083               switch (op[2] & 0x0f)
9084               {
9085                 case 0x00:
9086                 case 0x01:
9087                 case 0x02:
9088                 case 0x03:
9089                 case 0x04:
9090                 case 0x05:
9091                 case 0x06:
9092                 case 0x07:
9093                 case 0x08:
9094                 case 0x09:
9095                 case 0x0a:
9096                 case 0x0b:
9097                 case 0x0c:
9098                 case 0x0d:
9099                 case 0x0e:
9100                   goto op_semantics_73;
9101                   break;
9102                 case 0x0f:
9103                   goto op_semantics_74;
9104                   break;
9105               }
9106             break;
9107           case 0xe2:
9108               GETBYTE ();
9109               switch (op[2] & 0x0f)
9110               {
9111                 case 0x00:
9112                 case 0x01:
9113                 case 0x02:
9114                 case 0x03:
9115                 case 0x04:
9116                 case 0x05:
9117                 case 0x06:
9118                 case 0x07:
9119                 case 0x08:
9120                 case 0x09:
9121                 case 0x0a:
9122                 case 0x0b:
9123                 case 0x0c:
9124                 case 0x0d:
9125                 case 0x0e:
9126                   goto op_semantics_73;
9127                   break;
9128                 case 0x0f:
9129                   goto op_semantics_74;
9130                   break;
9131               }
9132             break;
9133           case 0xe3:
9134               GETBYTE ();
9135               switch (op[2] & 0x0f)
9136               {
9137                 case 0x00:
9138                 case 0x01:
9139                 case 0x02:
9140                 case 0x03:
9141                 case 0x04:
9142                 case 0x05:
9143                 case 0x06:
9144                 case 0x07:
9145                 case 0x08:
9146                 case 0x09:
9147                 case 0x0a:
9148                 case 0x0b:
9149                 case 0x0c:
9150                 case 0x0d:
9151                 case 0x0e:
9152                   goto op_semantics_73;
9153                   break;
9154                 case 0x0f:
9155                   goto op_semantics_74;
9156                   break;
9157               }
9158             break;
9159           case 0xe4:
9160               GETBYTE ();
9161               switch (op[2] & 0x0f)
9162               {
9163                 case 0x00:
9164                 case 0x01:
9165                 case 0x02:
9166                 case 0x03:
9167                 case 0x04:
9168                 case 0x05:
9169                 case 0x06:
9170                 case 0x07:
9171                 case 0x08:
9172                 case 0x09:
9173                 case 0x0a:
9174                 case 0x0b:
9175                 case 0x0c:
9176                 case 0x0d:
9177                 case 0x0e:
9178                   goto op_semantics_73;
9179                   break;
9180                 case 0x0f:
9181                   goto op_semantics_74;
9182                   break;
9183               }
9184             break;
9185           case 0xe5:
9186               GETBYTE ();
9187               switch (op[2] & 0x0f)
9188               {
9189                 case 0x00:
9190                 case 0x01:
9191                 case 0x02:
9192                 case 0x03:
9193                 case 0x04:
9194                 case 0x05:
9195                 case 0x06:
9196                 case 0x07:
9197                 case 0x08:
9198                 case 0x09:
9199                 case 0x0a:
9200                 case 0x0b:
9201                 case 0x0c:
9202                 case 0x0d:
9203                 case 0x0e:
9204                   goto op_semantics_73;
9205                   break;
9206                 case 0x0f:
9207                   goto op_semantics_74;
9208                   break;
9209               }
9210             break;
9211           case 0xe6:
9212               GETBYTE ();
9213               switch (op[2] & 0x0f)
9214               {
9215                 case 0x00:
9216                 case 0x01:
9217                 case 0x02:
9218                 case 0x03:
9219                 case 0x04:
9220                 case 0x05:
9221                 case 0x06:
9222                 case 0x07:
9223                 case 0x08:
9224                 case 0x09:
9225                 case 0x0a:
9226                 case 0x0b:
9227                 case 0x0c:
9228                 case 0x0d:
9229                 case 0x0e:
9230                   goto op_semantics_73;
9231                   break;
9232                 case 0x0f:
9233                   goto op_semantics_74;
9234                   break;
9235               }
9236             break;
9237           case 0xe7:
9238               GETBYTE ();
9239               switch (op[2] & 0x0f)
9240               {
9241                 case 0x00:
9242                 case 0x01:
9243                 case 0x02:
9244                 case 0x03:
9245                 case 0x04:
9246                 case 0x05:
9247                 case 0x06:
9248                 case 0x07:
9249                 case 0x08:
9250                 case 0x09:
9251                 case 0x0a:
9252                 case 0x0b:
9253                 case 0x0c:
9254                 case 0x0d:
9255                 case 0x0e:
9256                   goto op_semantics_73;
9257                   break;
9258                 case 0x0f:
9259                   goto op_semantics_74;
9260                   break;
9261               }
9262             break;
9263           case 0xe8:
9264               GETBYTE ();
9265               switch (op[2] & 0x0f)
9266               {
9267                 case 0x00:
9268                 case 0x01:
9269                 case 0x02:
9270                 case 0x03:
9271                 case 0x04:
9272                 case 0x05:
9273                 case 0x06:
9274                 case 0x07:
9275                 case 0x08:
9276                 case 0x09:
9277                 case 0x0a:
9278                 case 0x0b:
9279                 case 0x0c:
9280                 case 0x0d:
9281                 case 0x0e:
9282                   goto op_semantics_73;
9283                   break;
9284                 case 0x0f:
9285                   goto op_semantics_74;
9286                   break;
9287               }
9288             break;
9289           case 0xe9:
9290               GETBYTE ();
9291               switch (op[2] & 0x0f)
9292               {
9293                 case 0x00:
9294                 case 0x01:
9295                 case 0x02:
9296                 case 0x03:
9297                 case 0x04:
9298                 case 0x05:
9299                 case 0x06:
9300                 case 0x07:
9301                 case 0x08:
9302                 case 0x09:
9303                 case 0x0a:
9304                 case 0x0b:
9305                 case 0x0c:
9306                 case 0x0d:
9307                 case 0x0e:
9308                   goto op_semantics_73;
9309                   break;
9310                 case 0x0f:
9311                   goto op_semantics_74;
9312                   break;
9313               }
9314             break;
9315           case 0xea:
9316               GETBYTE ();
9317               switch (op[2] & 0x0f)
9318               {
9319                 case 0x00:
9320                 case 0x01:
9321                 case 0x02:
9322                 case 0x03:
9323                 case 0x04:
9324                 case 0x05:
9325                 case 0x06:
9326                 case 0x07:
9327                 case 0x08:
9328                 case 0x09:
9329                 case 0x0a:
9330                 case 0x0b:
9331                 case 0x0c:
9332                 case 0x0d:
9333                 case 0x0e:
9334                   goto op_semantics_73;
9335                   break;
9336                 case 0x0f:
9337                   goto op_semantics_74;
9338                   break;
9339               }
9340             break;
9341           case 0xeb:
9342               GETBYTE ();
9343               switch (op[2] & 0x0f)
9344               {
9345                 case 0x00:
9346                 case 0x01:
9347                 case 0x02:
9348                 case 0x03:
9349                 case 0x04:
9350                 case 0x05:
9351                 case 0x06:
9352                 case 0x07:
9353                 case 0x08:
9354                 case 0x09:
9355                 case 0x0a:
9356                 case 0x0b:
9357                 case 0x0c:
9358                 case 0x0d:
9359                 case 0x0e:
9360                   goto op_semantics_73;
9361                   break;
9362                 case 0x0f:
9363                   goto op_semantics_74;
9364                   break;
9365               }
9366             break;
9367           case 0xec:
9368               GETBYTE ();
9369               switch (op[2] & 0x0f)
9370               {
9371                 case 0x00:
9372                 case 0x01:
9373                 case 0x02:
9374                 case 0x03:
9375                 case 0x04:
9376                 case 0x05:
9377                 case 0x06:
9378                 case 0x07:
9379                 case 0x08:
9380                 case 0x09:
9381                 case 0x0a:
9382                 case 0x0b:
9383                 case 0x0c:
9384                 case 0x0d:
9385                 case 0x0e:
9386                   goto op_semantics_73;
9387                   break;
9388                 case 0x0f:
9389                   goto op_semantics_74;
9390                   break;
9391               }
9392             break;
9393           case 0xed:
9394               GETBYTE ();
9395               switch (op[2] & 0x0f)
9396               {
9397                 case 0x00:
9398                 case 0x01:
9399                 case 0x02:
9400                 case 0x03:
9401                 case 0x04:
9402                 case 0x05:
9403                 case 0x06:
9404                 case 0x07:
9405                 case 0x08:
9406                 case 0x09:
9407                 case 0x0a:
9408                 case 0x0b:
9409                 case 0x0c:
9410                 case 0x0d:
9411                 case 0x0e:
9412                   goto op_semantics_73;
9413                   break;
9414                 case 0x0f:
9415                   goto op_semantics_74;
9416                   break;
9417               }
9418             break;
9419           case 0xee:
9420               GETBYTE ();
9421               switch (op[2] & 0x0f)
9422               {
9423                 case 0x00:
9424                 case 0x01:
9425                 case 0x02:
9426                 case 0x03:
9427                 case 0x04:
9428                 case 0x05:
9429                 case 0x06:
9430                 case 0x07:
9431                 case 0x08:
9432                 case 0x09:
9433                 case 0x0a:
9434                 case 0x0b:
9435                 case 0x0c:
9436                 case 0x0d:
9437                 case 0x0e:
9438                   goto op_semantics_73;
9439                   break;
9440                 case 0x0f:
9441                   goto op_semantics_74;
9442                   break;
9443               }
9444             break;
9445           case 0xef:
9446               GETBYTE ();
9447               switch (op[2] & 0x0f)
9448               {
9449                 case 0x00:
9450                 case 0x01:
9451                 case 0x02:
9452                 case 0x03:
9453                 case 0x04:
9454                 case 0x05:
9455                 case 0x06:
9456                 case 0x07:
9457                 case 0x08:
9458                 case 0x09:
9459                 case 0x0a:
9460                 case 0x0b:
9461                 case 0x0c:
9462                 case 0x0d:
9463                 case 0x0e:
9464                   goto op_semantics_73;
9465                   break;
9466                 case 0x0f:
9467                   goto op_semantics_74;
9468                   break;
9469               }
9470             break;
9471           case 0xf0:
9472               GETBYTE ();
9473               switch (op[2] & 0x0f)
9474               {
9475                 case 0x00:
9476                 case 0x01:
9477                 case 0x02:
9478                 case 0x03:
9479                 case 0x04:
9480                 case 0x05:
9481                 case 0x06:
9482                 case 0x07:
9483                 case 0x08:
9484                 case 0x09:
9485                 case 0x0a:
9486                 case 0x0b:
9487                 case 0x0c:
9488                 case 0x0d:
9489                 case 0x0e:
9490                   goto op_semantics_73;
9491                   break;
9492                 case 0x0f:
9493                   goto op_semantics_74;
9494                   break;
9495               }
9496             break;
9497           case 0xf1:
9498               GETBYTE ();
9499               switch (op[2] & 0x0f)
9500               {
9501                 case 0x00:
9502                 case 0x01:
9503                 case 0x02:
9504                 case 0x03:
9505                 case 0x04:
9506                 case 0x05:
9507                 case 0x06:
9508                 case 0x07:
9509                 case 0x08:
9510                 case 0x09:
9511                 case 0x0a:
9512                 case 0x0b:
9513                 case 0x0c:
9514                 case 0x0d:
9515                 case 0x0e:
9516                   goto op_semantics_73;
9517                   break;
9518                 case 0x0f:
9519                   goto op_semantics_74;
9520                   break;
9521               }
9522             break;
9523           case 0xf2:
9524               GETBYTE ();
9525               switch (op[2] & 0x0f)
9526               {
9527                 case 0x00:
9528                 case 0x01:
9529                 case 0x02:
9530                 case 0x03:
9531                 case 0x04:
9532                 case 0x05:
9533                 case 0x06:
9534                 case 0x07:
9535                 case 0x08:
9536                 case 0x09:
9537                 case 0x0a:
9538                 case 0x0b:
9539                 case 0x0c:
9540                 case 0x0d:
9541                 case 0x0e:
9542                   goto op_semantics_73;
9543                   break;
9544                 case 0x0f:
9545                   goto op_semantics_74;
9546                   break;
9547               }
9548             break;
9549           case 0xf3:
9550               GETBYTE ();
9551               switch (op[2] & 0x0f)
9552               {
9553                 case 0x00:
9554                 case 0x01:
9555                 case 0x02:
9556                 case 0x03:
9557                 case 0x04:
9558                 case 0x05:
9559                 case 0x06:
9560                 case 0x07:
9561                 case 0x08:
9562                 case 0x09:
9563                 case 0x0a:
9564                 case 0x0b:
9565                 case 0x0c:
9566                 case 0x0d:
9567                 case 0x0e:
9568                   goto op_semantics_73;
9569                   break;
9570                 case 0x0f:
9571                   goto op_semantics_74;
9572                   break;
9573               }
9574             break;
9575           case 0xf4:
9576               GETBYTE ();
9577               switch (op[2] & 0x0f)
9578               {
9579                 case 0x00:
9580                 case 0x01:
9581                 case 0x02:
9582                 case 0x03:
9583                 case 0x04:
9584                 case 0x05:
9585                 case 0x06:
9586                 case 0x07:
9587                 case 0x08:
9588                 case 0x09:
9589                 case 0x0a:
9590                 case 0x0b:
9591                 case 0x0c:
9592                 case 0x0d:
9593                 case 0x0e:
9594                   goto op_semantics_73;
9595                   break;
9596                 case 0x0f:
9597                   goto op_semantics_74;
9598                   break;
9599               }
9600             break;
9601           case 0xf5:
9602               GETBYTE ();
9603               switch (op[2] & 0x0f)
9604               {
9605                 case 0x00:
9606                 case 0x01:
9607                 case 0x02:
9608                 case 0x03:
9609                 case 0x04:
9610                 case 0x05:
9611                 case 0x06:
9612                 case 0x07:
9613                 case 0x08:
9614                 case 0x09:
9615                 case 0x0a:
9616                 case 0x0b:
9617                 case 0x0c:
9618                 case 0x0d:
9619                 case 0x0e:
9620                   goto op_semantics_73;
9621                   break;
9622                 case 0x0f:
9623                   goto op_semantics_74;
9624                   break;
9625               }
9626             break;
9627           case 0xf6:
9628               GETBYTE ();
9629               switch (op[2] & 0x0f)
9630               {
9631                 case 0x00:
9632                 case 0x01:
9633                 case 0x02:
9634                 case 0x03:
9635                 case 0x04:
9636                 case 0x05:
9637                 case 0x06:
9638                 case 0x07:
9639                 case 0x08:
9640                 case 0x09:
9641                 case 0x0a:
9642                 case 0x0b:
9643                 case 0x0c:
9644                 case 0x0d:
9645                 case 0x0e:
9646                   goto op_semantics_73;
9647                   break;
9648                 case 0x0f:
9649                   goto op_semantics_74;
9650                   break;
9651               }
9652             break;
9653           case 0xf7:
9654               GETBYTE ();
9655               switch (op[2] & 0x0f)
9656               {
9657                 case 0x00:
9658                 case 0x01:
9659                 case 0x02:
9660                 case 0x03:
9661                 case 0x04:
9662                 case 0x05:
9663                 case 0x06:
9664                 case 0x07:
9665                 case 0x08:
9666                 case 0x09:
9667                 case 0x0a:
9668                 case 0x0b:
9669                 case 0x0c:
9670                 case 0x0d:
9671                 case 0x0e:
9672                   goto op_semantics_73;
9673                   break;
9674                 case 0x0f:
9675                   goto op_semantics_74;
9676                   break;
9677               }
9678             break;
9679           case 0xf8:
9680               GETBYTE ();
9681               switch (op[2] & 0x0f)
9682               {
9683                 case 0x00:
9684                 case 0x01:
9685                 case 0x02:
9686                 case 0x03:
9687                 case 0x04:
9688                 case 0x05:
9689                 case 0x06:
9690                 case 0x07:
9691                 case 0x08:
9692                 case 0x09:
9693                 case 0x0a:
9694                 case 0x0b:
9695                 case 0x0c:
9696                 case 0x0d:
9697                 case 0x0e:
9698                   goto op_semantics_73;
9699                   break;
9700                 case 0x0f:
9701                   goto op_semantics_74;
9702                   break;
9703               }
9704             break;
9705           case 0xf9:
9706               GETBYTE ();
9707               switch (op[2] & 0x0f)
9708               {
9709                 case 0x00:
9710                 case 0x01:
9711                 case 0x02:
9712                 case 0x03:
9713                 case 0x04:
9714                 case 0x05:
9715                 case 0x06:
9716                 case 0x07:
9717                 case 0x08:
9718                 case 0x09:
9719                 case 0x0a:
9720                 case 0x0b:
9721                 case 0x0c:
9722                 case 0x0d:
9723                 case 0x0e:
9724                   goto op_semantics_73;
9725                   break;
9726                 case 0x0f:
9727                   goto op_semantics_74;
9728                   break;
9729               }
9730             break;
9731           case 0xfa:
9732               GETBYTE ();
9733               switch (op[2] & 0x0f)
9734               {
9735                 case 0x00:
9736                 case 0x01:
9737                 case 0x02:
9738                 case 0x03:
9739                 case 0x04:
9740                 case 0x05:
9741                 case 0x06:
9742                 case 0x07:
9743                 case 0x08:
9744                 case 0x09:
9745                 case 0x0a:
9746                 case 0x0b:
9747                 case 0x0c:
9748                 case 0x0d:
9749                 case 0x0e:
9750                   goto op_semantics_73;
9751                   break;
9752                 case 0x0f:
9753                   goto op_semantics_74;
9754                   break;
9755               }
9756             break;
9757           case 0xfb:
9758               GETBYTE ();
9759               switch (op[2] & 0x0f)
9760               {
9761                 case 0x00:
9762                 case 0x01:
9763                 case 0x02:
9764                 case 0x03:
9765                 case 0x04:
9766                 case 0x05:
9767                 case 0x06:
9768                 case 0x07:
9769                 case 0x08:
9770                 case 0x09:
9771                 case 0x0a:
9772                 case 0x0b:
9773                 case 0x0c:
9774                 case 0x0d:
9775                 case 0x0e:
9776                   goto op_semantics_73;
9777                   break;
9778                 case 0x0f:
9779                   goto op_semantics_74;
9780                   break;
9781               }
9782             break;
9783           case 0xfc:
9784               GETBYTE ();
9785               switch (op[2] & 0x0f)
9786               {
9787                 case 0x00:
9788                 case 0x01:
9789                 case 0x02:
9790                 case 0x03:
9791                 case 0x04:
9792                 case 0x05:
9793                 case 0x06:
9794                 case 0x07:
9795                 case 0x08:
9796                 case 0x09:
9797                 case 0x0a:
9798                 case 0x0b:
9799                 case 0x0c:
9800                 case 0x0d:
9801                 case 0x0e:
9802                   goto op_semantics_73;
9803                   break;
9804                 case 0x0f:
9805                   goto op_semantics_74;
9806                   break;
9807               }
9808             break;
9809           case 0xfd:
9810               GETBYTE ();
9811               switch (op[2] & 0x0f)
9812               {
9813                 case 0x00:
9814                 case 0x01:
9815                 case 0x02:
9816                 case 0x03:
9817                 case 0x04:
9818                 case 0x05:
9819                 case 0x06:
9820                 case 0x07:
9821                 case 0x08:
9822                 case 0x09:
9823                 case 0x0a:
9824                 case 0x0b:
9825                 case 0x0c:
9826                 case 0x0d:
9827                 case 0x0e:
9828                   goto op_semantics_73;
9829                   break;
9830                 case 0x0f:
9831                   goto op_semantics_74;
9832                   break;
9833               }
9834             break;
9835           case 0xfe:
9836               GETBYTE ();
9837               switch (op[2] & 0x0f)
9838               {
9839                 case 0x00:
9840                 case 0x01:
9841                 case 0x02:
9842                 case 0x03:
9843                 case 0x04:
9844                 case 0x05:
9845                 case 0x06:
9846                 case 0x07:
9847                 case 0x08:
9848                 case 0x09:
9849                 case 0x0a:
9850                 case 0x0b:
9851                 case 0x0c:
9852                 case 0x0d:
9853                 case 0x0e:
9854                   goto op_semantics_73;
9855                   break;
9856                 case 0x0f:
9857                   goto op_semantics_74;
9858                   break;
9859               }
9860             break;
9861           case 0xff:
9862               GETBYTE ();
9863               switch (op[2] & 0x0f)
9864               {
9865                 case 0x00:
9866                 case 0x01:
9867                 case 0x02:
9868                 case 0x03:
9869                 case 0x04:
9870                 case 0x05:
9871                 case 0x06:
9872                 case 0x07:
9873                 case 0x08:
9874                 case 0x09:
9875                 case 0x0a:
9876                 case 0x0b:
9877                 case 0x0c:
9878                 case 0x0d:
9879                 case 0x0e:
9880                   goto op_semantics_73;
9881                   break;
9882                 case 0x0f:
9883                   goto op_semantics_74;
9884                   break;
9885               }
9886             break;
9887           default: UNSUPPORTED(); break;
9888         }
9889       break;
9890     case 0xfd:
9891         GETBYTE ();
9892         switch (op[1] & 0xff)
9893         {
9894           case 0x00:
9895               GETBYTE ();
9896               switch (op[2] & 0x00)
9897               {
9898                 case 0x00:
9899                   op_semantics_75:
9900                     {
9901                       /** 1111 1101 0000 a000 srca srcb mulhi   %1, %2, %0 */
9902 #line 852 "rx-decode.opc"
9903                       int a AU = (op[1] >> 3) & 0x01;
9904 #line 852 "rx-decode.opc"
9905                       int srca AU = (op[2] >> 4) & 0x0f;
9906 #line 852 "rx-decode.opc"
9907                       int srcb AU = op[2] & 0x0f;
9908                       if (trace)
9909                         {
9910                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9911                                  "/** 1111 1101 0000 a000 srca srcb     mulhi   %1, %2, %0 */",
9912                                  op[0], op[1], op[2]);
9913                           printf ("  a = 0x%x,", a);
9914                           printf ("  srca = 0x%x,", srca);
9915                           printf ("  srcb = 0x%x\n", srcb);
9916                         }
9917                       SYNTAX("mulhi     %1, %2, %0");
9918 #line 852 "rx-decode.opc"
9919                       ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
9920
9921                     }
9922                   break;
9923               }
9924             break;
9925           case 0x01:
9926               GETBYTE ();
9927               switch (op[2] & 0x00)
9928               {
9929                 case 0x00:
9930                   op_semantics_76:
9931                     {
9932                       /** 1111 1101 0000 a001 srca srcb mullo   %1, %2, %0 */
9933 #line 855 "rx-decode.opc"
9934                       int a AU = (op[1] >> 3) & 0x01;
9935 #line 855 "rx-decode.opc"
9936                       int srca AU = (op[2] >> 4) & 0x0f;
9937 #line 855 "rx-decode.opc"
9938                       int srcb AU = op[2] & 0x0f;
9939                       if (trace)
9940                         {
9941                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9942                                  "/** 1111 1101 0000 a001 srca srcb     mullo   %1, %2, %0 */",
9943                                  op[0], op[1], op[2]);
9944                           printf ("  a = 0x%x,", a);
9945                           printf ("  srca = 0x%x,", srca);
9946                           printf ("  srcb = 0x%x\n", srcb);
9947                         }
9948                       SYNTAX("mullo     %1, %2, %0");
9949 #line 855 "rx-decode.opc"
9950                       ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
9951
9952                     }
9953                   break;
9954               }
9955             break;
9956           case 0x02:
9957               GETBYTE ();
9958               switch (op[2] & 0x00)
9959               {
9960                 case 0x00:
9961                   op_semantics_77:
9962                     {
9963                       /** 1111 1101 0000 a010 srca srcb mullh   %1, %2, %0 */
9964 #line 1083 "rx-decode.opc"
9965                       int a AU = (op[1] >> 3) & 0x01;
9966 #line 1083 "rx-decode.opc"
9967                       int srca AU = (op[2] >> 4) & 0x0f;
9968 #line 1083 "rx-decode.opc"
9969                       int srcb AU = op[2] & 0x0f;
9970                       if (trace)
9971                         {
9972                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9973                                  "/** 1111 1101 0000 a010 srca srcb     mullh   %1, %2, %0 */",
9974                                  op[0], op[1], op[2]);
9975                           printf ("  a = 0x%x,", a);
9976                           printf ("  srca = 0x%x,", srca);
9977                           printf ("  srcb = 0x%x\n", srcb);
9978                         }
9979                       SYNTAX("mullh     %1, %2, %0");
9980 #line 1083 "rx-decode.opc"
9981                       ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
9982
9983                     }
9984                   break;
9985               }
9986             break;
9987           case 0x03:
9988               GETBYTE ();
9989               switch (op[2] & 0x00)
9990               {
9991                 case 0x00:
9992                   op_semantics_78:
9993                     {
9994                       /** 1111 1101 0000 a011 srca srcb         emula   %1, %2, %0 */
9995 #line 1068 "rx-decode.opc"
9996                       int a AU = (op[1] >> 3) & 0x01;
9997 #line 1068 "rx-decode.opc"
9998                       int srca AU = (op[2] >> 4) & 0x0f;
9999 #line 1068 "rx-decode.opc"
10000                       int srcb AU = op[2] & 0x0f;
10001                       if (trace)
10002                         {
10003                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10004                                  "/** 1111 1101 0000 a011 srca srcb     emula   %1, %2, %0 */",
10005                                  op[0], op[1], op[2]);
10006                           printf ("  a = 0x%x,", a);
10007                           printf ("  srca = 0x%x,", srca);
10008                           printf ("  srcb = 0x%x\n", srcb);
10009                         }
10010                       SYNTAX("emula     %1, %2, %0");
10011 #line 1068 "rx-decode.opc"
10012                       ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
10013
10014                     }
10015                   break;
10016               }
10017             break;
10018           case 0x04:
10019               GETBYTE ();
10020               switch (op[2] & 0x00)
10021               {
10022                 case 0x00:
10023                   op_semantics_79:
10024                     {
10025                       /** 1111 1101 0000 a100 srca srcb machi   %1, %2, %0 */
10026 #line 858 "rx-decode.opc"
10027                       int a AU = (op[1] >> 3) & 0x01;
10028 #line 858 "rx-decode.opc"
10029                       int srca AU = (op[2] >> 4) & 0x0f;
10030 #line 858 "rx-decode.opc"
10031                       int srcb AU = op[2] & 0x0f;
10032                       if (trace)
10033                         {
10034                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10035                                  "/** 1111 1101 0000 a100 srca srcb     machi   %1, %2, %0 */",
10036                                  op[0], op[1], op[2]);
10037                           printf ("  a = 0x%x,", a);
10038                           printf ("  srca = 0x%x,", srca);
10039                           printf ("  srcb = 0x%x\n", srcb);
10040                         }
10041                       SYNTAX("machi     %1, %2, %0");
10042 #line 858 "rx-decode.opc"
10043                       ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
10044
10045                     }
10046                   break;
10047               }
10048             break;
10049           case 0x05:
10050               GETBYTE ();
10051               switch (op[2] & 0x00)
10052               {
10053                 case 0x00:
10054                   op_semantics_80:
10055                     {
10056                       /** 1111 1101 0000 a101 srca srcb maclo   %1, %2, %0 */
10057 #line 861 "rx-decode.opc"
10058                       int a AU = (op[1] >> 3) & 0x01;
10059 #line 861 "rx-decode.opc"
10060                       int srca AU = (op[2] >> 4) & 0x0f;
10061 #line 861 "rx-decode.opc"
10062                       int srcb AU = op[2] & 0x0f;
10063                       if (trace)
10064                         {
10065                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10066                                  "/** 1111 1101 0000 a101 srca srcb     maclo   %1, %2, %0 */",
10067                                  op[0], op[1], op[2]);
10068                           printf ("  a = 0x%x,", a);
10069                           printf ("  srca = 0x%x,", srca);
10070                           printf ("  srcb = 0x%x\n", srcb);
10071                         }
10072                       SYNTAX("maclo     %1, %2, %0");
10073 #line 861 "rx-decode.opc"
10074                       ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
10075
10076                     }
10077                   break;
10078               }
10079             break;
10080           case 0x06:
10081               GETBYTE ();
10082               switch (op[2] & 0x00)
10083               {
10084                 case 0x00:
10085                   op_semantics_81:
10086                     {
10087                       /** 1111 1101 0000 a110 srca srcb maclh   %1, %2, %0 */
10088 #line 1071 "rx-decode.opc"
10089                       int a AU = (op[1] >> 3) & 0x01;
10090 #line 1071 "rx-decode.opc"
10091                       int srca AU = (op[2] >> 4) & 0x0f;
10092 #line 1071 "rx-decode.opc"
10093                       int srcb AU = op[2] & 0x0f;
10094                       if (trace)
10095                         {
10096                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10097                                  "/** 1111 1101 0000 a110 srca srcb     maclh   %1, %2, %0 */",
10098                                  op[0], op[1], op[2]);
10099                           printf ("  a = 0x%x,", a);
10100                           printf ("  srca = 0x%x,", srca);
10101                           printf ("  srcb = 0x%x\n", srcb);
10102                         }
10103                       SYNTAX("maclh     %1, %2, %0");
10104 #line 1071 "rx-decode.opc"
10105                       ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
10106
10107                     }
10108                   break;
10109               }
10110             break;
10111           case 0x07:
10112               GETBYTE ();
10113               switch (op[2] & 0x00)
10114               {
10115                 case 0x00:
10116                   op_semantics_82:
10117                     {
10118                       /** 1111 1101 0000 a111 srca srcb         emaca   %1, %2, %0 */
10119 #line 1062 "rx-decode.opc"
10120                       int a AU = (op[1] >> 3) & 0x01;
10121 #line 1062 "rx-decode.opc"
10122                       int srca AU = (op[2] >> 4) & 0x0f;
10123 #line 1062 "rx-decode.opc"
10124                       int srcb AU = op[2] & 0x0f;
10125                       if (trace)
10126                         {
10127                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10128                                  "/** 1111 1101 0000 a111 srca srcb     emaca   %1, %2, %0 */",
10129                                  op[0], op[1], op[2]);
10130                           printf ("  a = 0x%x,", a);
10131                           printf ("  srca = 0x%x,", srca);
10132                           printf ("  srcb = 0x%x\n", srcb);
10133                         }
10134                       SYNTAX("emaca     %1, %2, %0");
10135 #line 1062 "rx-decode.opc"
10136                       ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
10137
10138                     }
10139                   break;
10140               }
10141             break;
10142           case 0x08:
10143               GETBYTE ();
10144               switch (op[2] & 0x00)
10145               {
10146                 case 0x00:
10147                   goto op_semantics_75;
10148                   break;
10149               }
10150             break;
10151           case 0x09:
10152               GETBYTE ();
10153               switch (op[2] & 0x00)
10154               {
10155                 case 0x00:
10156                   goto op_semantics_76;
10157                   break;
10158               }
10159             break;
10160           case 0x0a:
10161               GETBYTE ();
10162               switch (op[2] & 0x00)
10163               {
10164                 case 0x00:
10165                   goto op_semantics_77;
10166                   break;
10167               }
10168             break;
10169           case 0x0b:
10170               GETBYTE ();
10171               switch (op[2] & 0x00)
10172               {
10173                 case 0x00:
10174                   goto op_semantics_78;
10175                   break;
10176               }
10177             break;
10178           case 0x0c:
10179               GETBYTE ();
10180               switch (op[2] & 0x00)
10181               {
10182                 case 0x00:
10183                   goto op_semantics_79;
10184                   break;
10185               }
10186             break;
10187           case 0x0d:
10188               GETBYTE ();
10189               switch (op[2] & 0x00)
10190               {
10191                 case 0x00:
10192                   goto op_semantics_80;
10193                   break;
10194               }
10195             break;
10196           case 0x0e:
10197               GETBYTE ();
10198               switch (op[2] & 0x00)
10199               {
10200                 case 0x00:
10201                   goto op_semantics_81;
10202                   break;
10203               }
10204             break;
10205           case 0x0f:
10206               GETBYTE ();
10207               switch (op[2] & 0x00)
10208               {
10209                 case 0x00:
10210                   goto op_semantics_82;
10211                   break;
10212               }
10213             break;
10214           case 0x17:
10215               GETBYTE ();
10216               switch (op[2] & 0x70)
10217               {
10218                 case 0x00:
10219                     {
10220                       /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
10221 #line 864 "rx-decode.opc"
10222                       int a AU = (op[2] >> 7) & 0x01;
10223 #line 864 "rx-decode.opc"
10224                       int rsrc AU = op[2] & 0x0f;
10225                       if (trace)
10226                         {
10227                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10228                                  "/** 1111 1101 0001 0111 a000 rsrc     mvtachi %1, %0 */",
10229                                  op[0], op[1], op[2]);
10230                           printf ("  a = 0x%x,", a);
10231                           printf ("  rsrc = 0x%x\n", rsrc);
10232                         }
10233                       SYNTAX("mvtachi   %1, %0");
10234 #line 864 "rx-decode.opc"
10235                       ID(mvtachi); DR(a+32); SR(rsrc); F_____;
10236
10237                     }
10238                   break;
10239                 case 0x10:
10240                     {
10241                       /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
10242 #line 867 "rx-decode.opc"
10243                       int a AU = (op[2] >> 7) & 0x01;
10244 #line 867 "rx-decode.opc"
10245                       int rsrc AU = op[2] & 0x0f;
10246                       if (trace)
10247                         {
10248                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10249                                  "/** 1111 1101 0001 0111 a001 rsrc     mvtaclo %1, %0 */",
10250                                  op[0], op[1], op[2]);
10251                           printf ("  a = 0x%x,", a);
10252                           printf ("  rsrc = 0x%x\n", rsrc);
10253                         }
10254                       SYNTAX("mvtaclo   %1, %0");
10255 #line 867 "rx-decode.opc"
10256                       ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
10257
10258                     }
10259                   break;
10260                 case 0x30:
10261                     {
10262                       /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */
10263 #line 1089 "rx-decode.opc"
10264                       int a AU = (op[2] >> 7) & 0x01;
10265 #line 1089 "rx-decode.opc"
10266                       int rdst AU = op[2] & 0x0f;
10267                       if (trace)
10268                         {
10269                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10270                                  "/** 1111 1101 0001 0111 a011 rdst     mvtacgu %0, %1 */",
10271                                  op[0], op[1], op[2]);
10272                           printf ("  a = 0x%x,", a);
10273                           printf ("  rdst = 0x%x\n", rdst);
10274                         }
10275                       SYNTAX("mvtacgu   %0, %1");
10276 #line 1089 "rx-decode.opc"
10277                       ID(mvtacgu); DR(a+32); SR(rdst); F_____;
10278
10279                     }
10280                   break;
10281                 default: UNSUPPORTED(); break;
10282               }
10283             break;
10284           case 0x18:
10285               GETBYTE ();
10286               switch (op[2] & 0x6f)
10287               {
10288                 case 0x00:
10289                     {
10290                       /** 1111 1101 0001 1000 a00i 0000 racw    #%1, %0 */
10291 #line 879 "rx-decode.opc"
10292                       int a AU = (op[2] >> 7) & 0x01;
10293 #line 879 "rx-decode.opc"
10294                       int i AU = (op[2] >> 4) & 0x01;
10295                       if (trace)
10296                         {
10297                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10298                                  "/** 1111 1101 0001 1000 a00i 0000     racw    #%1, %0 */",
10299                                  op[0], op[1], op[2]);
10300                           printf ("  a = 0x%x,", a);
10301                           printf ("  i = 0x%x\n", i);
10302                         }
10303                       SYNTAX("racw      #%1, %0");
10304 #line 879 "rx-decode.opc"
10305                       ID(racw); SC(i+1); DR(a+32); F_____;
10306
10307                     /*----------------------------------------------------------------------*/
10308                     /* SAT                                                                      */
10309
10310                     }
10311                   break;
10312                 case 0x40:
10313                     {
10314                       /** 1111 1101 0001 1000 a10i 0000 rdacw   #%1, %0 */
10315 #line 1098 "rx-decode.opc"
10316                       int a AU = (op[2] >> 7) & 0x01;
10317 #line 1098 "rx-decode.opc"
10318                       int i AU = (op[2] >> 4) & 0x01;
10319                       if (trace)
10320                         {
10321                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10322                                  "/** 1111 1101 0001 1000 a10i 0000     rdacw   #%1, %0 */",
10323                                  op[0], op[1], op[2]);
10324                           printf ("  a = 0x%x,", a);
10325                           printf ("  i = 0x%x\n", i);
10326                         }
10327                       SYNTAX("rdacw     #%1, %0");
10328 #line 1098 "rx-decode.opc"
10329                       ID(rdacw); SC(i+1); DR(a+32); F_____;
10330
10331                     }
10332                   break;
10333                 default: UNSUPPORTED(); break;
10334               }
10335             break;
10336           case 0x19:
10337               GETBYTE ();
10338               switch (op[2] & 0x6f)
10339               {
10340                 case 0x00:
10341                     {
10342                       /** 1111 1101 0001 1001 a00i 0000 racl    #%1, %0 */
10343 #line 1092 "rx-decode.opc"
10344                       int a AU = (op[2] >> 7) & 0x01;
10345 #line 1092 "rx-decode.opc"
10346                       int i AU = (op[2] >> 4) & 0x01;
10347                       if (trace)
10348                         {
10349                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10350                                  "/** 1111 1101 0001 1001 a00i 0000     racl    #%1, %0 */",
10351                                  op[0], op[1], op[2]);
10352                           printf ("  a = 0x%x,", a);
10353                           printf ("  i = 0x%x\n", i);
10354                         }
10355                       SYNTAX("racl      #%1, %0");
10356 #line 1092 "rx-decode.opc"
10357                       ID(racl); SC(i+1); DR(a+32); F_____;
10358
10359                     }
10360                   break;
10361                 case 0x40:
10362                     {
10363                       /** 1111 1101 0001 1001 a10i 0000 rdacl   #%1, %0 */
10364 #line 1095 "rx-decode.opc"
10365                       int a AU = (op[2] >> 7) & 0x01;
10366 #line 1095 "rx-decode.opc"
10367                       int i AU = (op[2] >> 4) & 0x01;
10368                       if (trace)
10369                         {
10370                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10371                                  "/** 1111 1101 0001 1001 a10i 0000     rdacl   #%1, %0 */",
10372                                  op[0], op[1], op[2]);
10373                           printf ("  a = 0x%x,", a);
10374                           printf ("  i = 0x%x\n", i);
10375                         }
10376                       SYNTAX("rdacl     #%1, %0");
10377 #line 1095 "rx-decode.opc"
10378                       ID(rdacl); SC(i+1); DR(a+32); F_____;
10379
10380                     }
10381                   break;
10382                 default: UNSUPPORTED(); break;
10383               }
10384             break;
10385           case 0x1e:
10386               GETBYTE ();
10387               switch (op[2] & 0x30)
10388               {
10389                 case 0x00:
10390                   op_semantics_83:
10391                     {
10392                       /** 1111 1101 0001 111i a m00 rdst        mvfachi #%2, %1, %0 */
10393 #line 870 "rx-decode.opc"
10394                       int i AU = op[1] & 0x01;
10395 #line 870 "rx-decode.opc"
10396                       int a AU = (op[2] >> 7) & 0x01;
10397 #line 870 "rx-decode.opc"
10398                       int m AU = (op[2] >> 6) & 0x01;
10399 #line 870 "rx-decode.opc"
10400                       int rdst AU = op[2] & 0x0f;
10401                       if (trace)
10402                         {
10403                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10404                                  "/** 1111 1101 0001 111i a m00 rdst    mvfachi #%2, %1, %0 */",
10405                                  op[0], op[1], op[2]);
10406                           printf ("  i = 0x%x,", i);
10407                           printf ("  a = 0x%x,", a);
10408                           printf ("  m = 0x%x,", m);
10409                           printf ("  rdst = 0x%x\n", rdst);
10410                         }
10411                       SYNTAX("mvfachi   #%2, %1, %0");
10412 #line 870 "rx-decode.opc"
10413                       ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10414
10415                     }
10416                   break;
10417                 case 0x10:
10418                   op_semantics_84:
10419                     {
10420                       /** 1111 1101 0001 111i a m01 rdst        mvfaclo #%2, %1, %0 */
10421 #line 876 "rx-decode.opc"
10422                       int i AU = op[1] & 0x01;
10423 #line 876 "rx-decode.opc"
10424                       int a AU = (op[2] >> 7) & 0x01;
10425 #line 876 "rx-decode.opc"
10426                       int m AU = (op[2] >> 6) & 0x01;
10427 #line 876 "rx-decode.opc"
10428                       int rdst AU = op[2] & 0x0f;
10429                       if (trace)
10430                         {
10431                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10432                                  "/** 1111 1101 0001 111i a m01 rdst    mvfaclo #%2, %1, %0 */",
10433                                  op[0], op[1], op[2]);
10434                           printf ("  i = 0x%x,", i);
10435                           printf ("  a = 0x%x,", a);
10436                           printf ("  m = 0x%x,", m);
10437                           printf ("  rdst = 0x%x\n", rdst);
10438                         }
10439                       SYNTAX("mvfaclo   #%2, %1, %0");
10440 #line 876 "rx-decode.opc"
10441                       ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10442
10443                     }
10444                   break;
10445                 case 0x20:
10446                   op_semantics_85:
10447                     {
10448                       /** 1111 1101 0001 111i a m10 rdst        mvfacmi #%2, %1, %0 */
10449 #line 873 "rx-decode.opc"
10450                       int i AU = op[1] & 0x01;
10451 #line 873 "rx-decode.opc"
10452                       int a AU = (op[2] >> 7) & 0x01;
10453 #line 873 "rx-decode.opc"
10454                       int m AU = (op[2] >> 6) & 0x01;
10455 #line 873 "rx-decode.opc"
10456                       int rdst AU = op[2] & 0x0f;
10457                       if (trace)
10458                         {
10459                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10460                                  "/** 1111 1101 0001 111i a m10 rdst    mvfacmi #%2, %1, %0 */",
10461                                  op[0], op[1], op[2]);
10462                           printf ("  i = 0x%x,", i);
10463                           printf ("  a = 0x%x,", a);
10464                           printf ("  m = 0x%x,", m);
10465                           printf ("  rdst = 0x%x\n", rdst);
10466                         }
10467                       SYNTAX("mvfacmi   #%2, %1, %0");
10468 #line 873 "rx-decode.opc"
10469                       ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10470
10471                     }
10472                   break;
10473                 case 0x30:
10474                   op_semantics_86:
10475                     {
10476                       /** 1111 1101 0001 111i a m11 rdst        mvfacgu #%2, %1, %0 */
10477 #line 1086 "rx-decode.opc"
10478                       int i AU = op[1] & 0x01;
10479 #line 1086 "rx-decode.opc"
10480                       int a AU = (op[2] >> 7) & 0x01;
10481 #line 1086 "rx-decode.opc"
10482                       int m AU = (op[2] >> 6) & 0x01;
10483 #line 1086 "rx-decode.opc"
10484                       int rdst AU = op[2] & 0x0f;
10485                       if (trace)
10486                         {
10487                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10488                                  "/** 1111 1101 0001 111i a m11 rdst    mvfacgu #%2, %1, %0 */",
10489                                  op[0], op[1], op[2]);
10490                           printf ("  i = 0x%x,", i);
10491                           printf ("  a = 0x%x,", a);
10492                           printf ("  m = 0x%x,", m);
10493                           printf ("  rdst = 0x%x\n", rdst);
10494                         }
10495                       SYNTAX("mvfacgu   #%2, %1, %0");
10496 #line 1086 "rx-decode.opc"
10497                       ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10498
10499                     }
10500                   break;
10501               }
10502             break;
10503           case 0x1f:
10504               GETBYTE ();
10505               switch (op[2] & 0x30)
10506               {
10507                 case 0x00:
10508                   goto op_semantics_83;
10509                   break;
10510                 case 0x10:
10511                   goto op_semantics_84;
10512                   break;
10513                 case 0x20:
10514                   goto op_semantics_85;
10515                   break;
10516                 case 0x30:
10517                   goto op_semantics_86;
10518                   break;
10519               }
10520             break;
10521           case 0x20:
10522               GETBYTE ();
10523               switch (op[2] & 0x00)
10524               {
10525                 case 0x00:
10526                   op_semantics_87:
10527                     {
10528                       /** 1111 1101 0010 0p sz rdst rsrc        mov%s   %1, %0 */
10529 #line 348 "rx-decode.opc"
10530                       int p AU = (op[1] >> 2) & 0x01;
10531 #line 348 "rx-decode.opc"
10532                       int sz AU = op[1] & 0x03;
10533 #line 348 "rx-decode.opc"
10534                       int rdst AU = (op[2] >> 4) & 0x0f;
10535 #line 348 "rx-decode.opc"
10536                       int rsrc AU = op[2] & 0x0f;
10537                       if (trace)
10538                         {
10539                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10540                                  "/** 1111 1101 0010 0p sz rdst rsrc    mov%s   %1, %0 */",
10541                                  op[0], op[1], op[2]);
10542                           printf ("  p = 0x%x,", p);
10543                           printf ("  sz = 0x%x,", sz);
10544                           printf ("  rdst = 0x%x,", rdst);
10545                           printf ("  rsrc = 0x%x\n", rsrc);
10546                         }
10547                       SYNTAX("mov%s     %1, %0");
10548 #line 348 "rx-decode.opc"
10549                       ID(mov); sBWL (sz); SR(rsrc); F_____;
10550                       OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
10551
10552                     }
10553                   break;
10554               }
10555             break;
10556           case 0x21:
10557               GETBYTE ();
10558               switch (op[2] & 0x00)
10559               {
10560                 case 0x00:
10561                   goto op_semantics_87;
10562                   break;
10563               }
10564             break;
10565           case 0x22:
10566               GETBYTE ();
10567               switch (op[2] & 0x00)
10568               {
10569                 case 0x00:
10570                   goto op_semantics_87;
10571                   break;
10572               }
10573             break;
10574           case 0x24:
10575               GETBYTE ();
10576               switch (op[2] & 0x00)
10577               {
10578                 case 0x00:
10579                   goto op_semantics_87;
10580                   break;
10581               }
10582             break;
10583           case 0x25:
10584               GETBYTE ();
10585               switch (op[2] & 0x00)
10586               {
10587                 case 0x00:
10588                   goto op_semantics_87;
10589                   break;
10590               }
10591             break;
10592           case 0x26:
10593               GETBYTE ();
10594               switch (op[2] & 0x00)
10595               {
10596                 case 0x00:
10597                   goto op_semantics_87;
10598                   break;
10599               }
10600             break;
10601           case 0x27:
10602               GETBYTE ();
10603               switch (op[2] & 0x00)
10604               {
10605                 case 0x00:
10606                     {
10607                       /** 1111 1101 0010 0111 rdst rsrc movco   %1, [%0] */
10608 #line 1050 "rx-decode.opc"
10609                       int rdst AU = (op[2] >> 4) & 0x0f;
10610 #line 1050 "rx-decode.opc"
10611                       int rsrc AU = op[2] & 0x0f;
10612                       if (trace)
10613                         {
10614                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10615                                  "/** 1111 1101 0010 0111 rdst rsrc     movco   %1, [%0] */",
10616                                  op[0], op[1], op[2]);
10617                           printf ("  rdst = 0x%x,", rdst);
10618                           printf ("  rsrc = 0x%x\n", rsrc);
10619                         }
10620                       SYNTAX("movco     %1, [%0]");
10621 #line 1050 "rx-decode.opc"
10622                        ID(movco); SR(rsrc); DR(rdst); F_____;
10623
10624                     }
10625                   break;
10626               }
10627             break;
10628           case 0x28:
10629               GETBYTE ();
10630               switch (op[2] & 0x00)
10631               {
10632                 case 0x00:
10633                   op_semantics_88:
10634                     {
10635                       /** 1111 1101 0010 1p sz rsrc rdst        mov%s   %1, %0 */
10636 #line 352 "rx-decode.opc"
10637                       int p AU = (op[1] >> 2) & 0x01;
10638 #line 352 "rx-decode.opc"
10639                       int sz AU = op[1] & 0x03;
10640 #line 352 "rx-decode.opc"
10641                       int rsrc AU = (op[2] >> 4) & 0x0f;
10642 #line 352 "rx-decode.opc"
10643                       int rdst AU = op[2] & 0x0f;
10644                       if (trace)
10645                         {
10646                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10647                                  "/** 1111 1101 0010 1p sz rsrc rdst    mov%s   %1, %0 */",
10648                                  op[0], op[1], op[2]);
10649                           printf ("  p = 0x%x,", p);
10650                           printf ("  sz = 0x%x,", sz);
10651                           printf ("  rsrc = 0x%x,", rsrc);
10652                           printf ("  rdst = 0x%x\n", rdst);
10653                         }
10654                       SYNTAX("mov%s     %1, %0");
10655 #line 352 "rx-decode.opc"
10656                       ID(mov); sBWL (sz); DR(rdst); F_____;
10657                       OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10658
10659                     }
10660                   break;
10661               }
10662             break;
10663           case 0x29:
10664               GETBYTE ();
10665               switch (op[2] & 0x00)
10666               {
10667                 case 0x00:
10668                   goto op_semantics_88;
10669                   break;
10670               }
10671             break;
10672           case 0x2a:
10673               GETBYTE ();
10674               switch (op[2] & 0x00)
10675               {
10676                 case 0x00:
10677                   goto op_semantics_88;
10678                   break;
10679               }
10680             break;
10681           case 0x2c:
10682               GETBYTE ();
10683               switch (op[2] & 0x00)
10684               {
10685                 case 0x00:
10686                   goto op_semantics_88;
10687                   break;
10688               }
10689             break;
10690           case 0x2d:
10691               GETBYTE ();
10692               switch (op[2] & 0x00)
10693               {
10694                 case 0x00:
10695                   goto op_semantics_88;
10696                   break;
10697               }
10698             break;
10699           case 0x2e:
10700               GETBYTE ();
10701               switch (op[2] & 0x00)
10702               {
10703                 case 0x00:
10704                   goto op_semantics_88;
10705                   break;
10706               }
10707             break;
10708           case 0x2f:
10709               GETBYTE ();
10710               switch (op[2] & 0x00)
10711               {
10712                 case 0x00:
10713                     {
10714                       /** 1111 1101 0010 1111 rsrc rdst movli   [%1], %0 */
10715 #line 1053 "rx-decode.opc"
10716                       int rsrc AU = (op[2] >> 4) & 0x0f;
10717 #line 1053 "rx-decode.opc"
10718                       int rdst AU = op[2] & 0x0f;
10719                       if (trace)
10720                         {
10721                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10722                                  "/** 1111 1101 0010 1111 rsrc rdst     movli   [%1], %0 */",
10723                                  op[0], op[1], op[2]);
10724                           printf ("  rsrc = 0x%x,", rsrc);
10725                           printf ("  rdst = 0x%x\n", rdst);
10726                         }
10727                       SYNTAX("movli     [%1], %0");
10728 #line 1053 "rx-decode.opc"
10729                        ID(movli); SR(rsrc); DR(rdst); F_____;
10730
10731                     }
10732                   break;
10733               }
10734             break;
10735           case 0x38:
10736               GETBYTE ();
10737               switch (op[2] & 0x00)
10738               {
10739                 case 0x00:
10740                   op_semantics_89:
10741                     {
10742                       /** 1111 1101 0011 1p sz rsrc rdst        movu%s  %1, %0 */
10743 #line 362 "rx-decode.opc"
10744                       int p AU = (op[1] >> 2) & 0x01;
10745 #line 362 "rx-decode.opc"
10746                       int sz AU = op[1] & 0x03;
10747 #line 362 "rx-decode.opc"
10748                       int rsrc AU = (op[2] >> 4) & 0x0f;
10749 #line 362 "rx-decode.opc"
10750                       int rdst AU = op[2] & 0x0f;
10751                       if (trace)
10752                         {
10753                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10754                                  "/** 1111 1101 0011 1p sz rsrc rdst    movu%s  %1, %0 */",
10755                                  op[0], op[1], op[2]);
10756                           printf ("  p = 0x%x,", p);
10757                           printf ("  sz = 0x%x,", sz);
10758                           printf ("  rsrc = 0x%x,", rsrc);
10759                           printf ("  rdst = 0x%x\n", rdst);
10760                         }
10761                       SYNTAX("movu%s    %1, %0");
10762 #line 362 "rx-decode.opc"
10763                       ID(mov); uBW (sz); DR(rdst); F_____;
10764                        OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10765
10766                     /*----------------------------------------------------------------------*/
10767                     /* PUSH/POP                                                         */
10768
10769                     }
10770                   break;
10771               }
10772             break;
10773           case 0x39:
10774               GETBYTE ();
10775               switch (op[2] & 0x00)
10776               {
10777                 case 0x00:
10778                   goto op_semantics_89;
10779                   break;
10780               }
10781             break;
10782           case 0x3a:
10783               GETBYTE ();
10784               switch (op[2] & 0x00)
10785               {
10786                 case 0x00:
10787                   goto op_semantics_89;
10788                   break;
10789               }
10790             break;
10791           case 0x3c:
10792               GETBYTE ();
10793               switch (op[2] & 0x00)
10794               {
10795                 case 0x00:
10796                   goto op_semantics_89;
10797                   break;
10798               }
10799             break;
10800           case 0x3d:
10801               GETBYTE ();
10802               switch (op[2] & 0x00)
10803               {
10804                 case 0x00:
10805                   goto op_semantics_89;
10806                   break;
10807               }
10808             break;
10809           case 0x3e:
10810               GETBYTE ();
10811               switch (op[2] & 0x00)
10812               {
10813                 case 0x00:
10814                   goto op_semantics_89;
10815                   break;
10816               }
10817             break;
10818           case 0x44:
10819               GETBYTE ();
10820               switch (op[2] & 0x00)
10821               {
10822                 case 0x00:
10823                   op_semantics_90:
10824                     {
10825                       /** 1111 1101 0100 a100 srca srcb msbhi   %1, %2, %0 */
10826 #line 1074 "rx-decode.opc"
10827                       int a AU = (op[1] >> 3) & 0x01;
10828 #line 1074 "rx-decode.opc"
10829                       int srca AU = (op[2] >> 4) & 0x0f;
10830 #line 1074 "rx-decode.opc"
10831                       int srcb AU = op[2] & 0x0f;
10832                       if (trace)
10833                         {
10834                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10835                                  "/** 1111 1101 0100 a100 srca srcb     msbhi   %1, %2, %0 */",
10836                                  op[0], op[1], op[2]);
10837                           printf ("  a = 0x%x,", a);
10838                           printf ("  srca = 0x%x,", srca);
10839                           printf ("  srcb = 0x%x\n", srcb);
10840                         }
10841                       SYNTAX("msbhi     %1, %2, %0");
10842 #line 1074 "rx-decode.opc"
10843                       ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
10844
10845                     }
10846                   break;
10847               }
10848             break;
10849           case 0x45:
10850               GETBYTE ();
10851               switch (op[2] & 0x00)
10852               {
10853                 case 0x00:
10854                   op_semantics_91:
10855                     {
10856                       /** 1111 1101 0100 a101 srca srcb msblo   %1, %2, %0 */
10857 #line 1080 "rx-decode.opc"
10858                       int a AU = (op[1] >> 3) & 0x01;
10859 #line 1080 "rx-decode.opc"
10860                       int srca AU = (op[2] >> 4) & 0x0f;
10861 #line 1080 "rx-decode.opc"
10862                       int srcb AU = op[2] & 0x0f;
10863                       if (trace)
10864                         {
10865                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10866                                  "/** 1111 1101 0100 a101 srca srcb     msblo   %1, %2, %0 */",
10867                                  op[0], op[1], op[2]);
10868                           printf ("  a = 0x%x,", a);
10869                           printf ("  srca = 0x%x,", srca);
10870                           printf ("  srcb = 0x%x\n", srcb);
10871                         }
10872                       SYNTAX("msblo     %1, %2, %0");
10873 #line 1080 "rx-decode.opc"
10874                       ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
10875
10876                     }
10877                   break;
10878               }
10879             break;
10880           case 0x46:
10881               GETBYTE ();
10882               switch (op[2] & 0x00)
10883               {
10884                 case 0x00:
10885                   op_semantics_92:
10886                     {
10887                       /** 1111 1101 0100 a110 srca srcb msblh   %1, %2, %0 */
10888 #line 1077 "rx-decode.opc"
10889                       int a AU = (op[1] >> 3) & 0x01;
10890 #line 1077 "rx-decode.opc"
10891                       int srca AU = (op[2] >> 4) & 0x0f;
10892 #line 1077 "rx-decode.opc"
10893                       int srcb AU = op[2] & 0x0f;
10894                       if (trace)
10895                         {
10896                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10897                                  "/** 1111 1101 0100 a110 srca srcb     msblh   %1, %2, %0 */",
10898                                  op[0], op[1], op[2]);
10899                           printf ("  a = 0x%x,", a);
10900                           printf ("  srca = 0x%x,", srca);
10901                           printf ("  srcb = 0x%x\n", srcb);
10902                         }
10903                       SYNTAX("msblh     %1, %2, %0");
10904 #line 1077 "rx-decode.opc"
10905                       ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
10906
10907                     }
10908                   break;
10909               }
10910             break;
10911           case 0x47:
10912               GETBYTE ();
10913               switch (op[2] & 0x00)
10914               {
10915                 case 0x00:
10916                   op_semantics_93:
10917                     {
10918                       /** 1111 1101 0100 a111 srca srcb         emsba   %1, %2, %0 */
10919 #line 1065 "rx-decode.opc"
10920                       int a AU = (op[1] >> 3) & 0x01;
10921 #line 1065 "rx-decode.opc"
10922                       int srca AU = (op[2] >> 4) & 0x0f;
10923 #line 1065 "rx-decode.opc"
10924                       int srcb AU = op[2] & 0x0f;
10925                       if (trace)
10926                         {
10927                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10928                                  "/** 1111 1101 0100 a111 srca srcb     emsba   %1, %2, %0 */",
10929                                  op[0], op[1], op[2]);
10930                           printf ("  a = 0x%x,", a);
10931                           printf ("  srca = 0x%x,", srca);
10932                           printf ("  srcb = 0x%x\n", srcb);
10933                         }
10934                       SYNTAX("emsba     %1, %2, %0");
10935 #line 1065 "rx-decode.opc"
10936                       ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
10937
10938                     }
10939                   break;
10940               }
10941             break;
10942           case 0x4c:
10943               GETBYTE ();
10944               switch (op[2] & 0x00)
10945               {
10946                 case 0x00:
10947                   goto op_semantics_90;
10948                   break;
10949               }
10950             break;
10951           case 0x4d:
10952               GETBYTE ();
10953               switch (op[2] & 0x00)
10954               {
10955                 case 0x00:
10956                   goto op_semantics_91;
10957                   break;
10958               }
10959             break;
10960           case 0x4e:
10961               GETBYTE ();
10962               switch (op[2] & 0x00)
10963               {
10964                 case 0x00:
10965                   goto op_semantics_92;
10966                   break;
10967               }
10968             break;
10969           case 0x4f:
10970               GETBYTE ();
10971               switch (op[2] & 0x00)
10972               {
10973                 case 0x00:
10974                   goto op_semantics_93;
10975                   break;
10976               }
10977             break;
10978           case 0x60:
10979               GETBYTE ();
10980               switch (op[2] & 0x00)
10981               {
10982                 case 0x00:
10983                     {
10984                       /** 1111 1101 0110 0000 rsrc rdst shlr    %2, %0 */
10985 #line 733 "rx-decode.opc"
10986                       int rsrc AU = (op[2] >> 4) & 0x0f;
10987 #line 733 "rx-decode.opc"
10988                       int rdst AU = op[2] & 0x0f;
10989                       if (trace)
10990                         {
10991                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10992                                  "/** 1111 1101 0110 0000 rsrc rdst     shlr    %2, %0 */",
10993                                  op[0], op[1], op[2]);
10994                           printf ("  rsrc = 0x%x,", rsrc);
10995                           printf ("  rdst = 0x%x\n", rdst);
10996                         }
10997                       SYNTAX("shlr      %2, %0");
10998 #line 733 "rx-decode.opc"
10999                       ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
11000
11001                     }
11002                   break;
11003               }
11004             break;
11005           case 0x61:
11006               GETBYTE ();
11007               switch (op[2] & 0x00)
11008               {
11009                 case 0x00:
11010                     {
11011                       /** 1111 1101 0110 0001 rsrc rdst shar    %2, %0 */
11012 #line 723 "rx-decode.opc"
11013                       int rsrc AU = (op[2] >> 4) & 0x0f;
11014 #line 723 "rx-decode.opc"
11015                       int rdst AU = op[2] & 0x0f;
11016                       if (trace)
11017                         {
11018                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11019                                  "/** 1111 1101 0110 0001 rsrc rdst     shar    %2, %0 */",
11020                                  op[0], op[1], op[2]);
11021                           printf ("  rsrc = 0x%x,", rsrc);
11022                           printf ("  rdst = 0x%x\n", rdst);
11023                         }
11024                       SYNTAX("shar      %2, %0");
11025 #line 723 "rx-decode.opc"
11026                       ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
11027
11028                     }
11029                   break;
11030               }
11031             break;
11032           case 0x62:
11033               GETBYTE ();
11034               switch (op[2] & 0x00)
11035               {
11036                 case 0x00:
11037                     {
11038                       /** 1111 1101 0110 0010 rsrc rdst shll    %2, %0 */
11039 #line 713 "rx-decode.opc"
11040                       int rsrc AU = (op[2] >> 4) & 0x0f;
11041 #line 713 "rx-decode.opc"
11042                       int rdst AU = op[2] & 0x0f;
11043                       if (trace)
11044                         {
11045                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11046                                  "/** 1111 1101 0110 0010 rsrc rdst     shll    %2, %0 */",
11047                                  op[0], op[1], op[2]);
11048                           printf ("  rsrc = 0x%x,", rsrc);
11049                           printf ("  rdst = 0x%x\n", rdst);
11050                         }
11051                       SYNTAX("shll      %2, %0");
11052 #line 713 "rx-decode.opc"
11053                       ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
11054
11055                     }
11056                   break;
11057               }
11058             break;
11059           case 0x64:
11060               GETBYTE ();
11061               switch (op[2] & 0x00)
11062               {
11063                 case 0x00:
11064                     {
11065                       /** 1111 1101 0110 0100 rsrc rdst rotr    %1, %0 */
11066 #line 757 "rx-decode.opc"
11067                       int rsrc AU = (op[2] >> 4) & 0x0f;
11068 #line 757 "rx-decode.opc"
11069                       int rdst AU = op[2] & 0x0f;
11070                       if (trace)
11071                         {
11072                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11073                                  "/** 1111 1101 0110 0100 rsrc rdst     rotr    %1, %0 */",
11074                                  op[0], op[1], op[2]);
11075                           printf ("  rsrc = 0x%x,", rsrc);
11076                           printf ("  rdst = 0x%x\n", rdst);
11077                         }
11078                       SYNTAX("rotr      %1, %0");
11079 #line 757 "rx-decode.opc"
11080                       ID(rotr); SR(rsrc); DR(rdst); F__SZC;
11081
11082                     }
11083                   break;
11084               }
11085             break;
11086           case 0x65:
11087               GETBYTE ();
11088               switch (op[2] & 0x00)
11089               {
11090                 case 0x00:
11091                     {
11092                       /** 1111 1101 0110 0101 rsrc rdst revw    %1, %0 */
11093 #line 760 "rx-decode.opc"
11094                       int rsrc AU = (op[2] >> 4) & 0x0f;
11095 #line 760 "rx-decode.opc"
11096                       int rdst AU = op[2] & 0x0f;
11097                       if (trace)
11098                         {
11099                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11100                                  "/** 1111 1101 0110 0101 rsrc rdst     revw    %1, %0 */",
11101                                  op[0], op[1], op[2]);
11102                           printf ("  rsrc = 0x%x,", rsrc);
11103                           printf ("  rdst = 0x%x\n", rdst);
11104                         }
11105                       SYNTAX("revw      %1, %0");
11106 #line 760 "rx-decode.opc"
11107                       ID(revw); SR(rsrc); DR(rdst);
11108
11109                     }
11110                   break;
11111               }
11112             break;
11113           case 0x66:
11114               GETBYTE ();
11115               switch (op[2] & 0x00)
11116               {
11117                 case 0x00:
11118                     {
11119                       /** 1111 1101 0110 0110 rsrc rdst rotl    %1, %0 */
11120 #line 751 "rx-decode.opc"
11121                       int rsrc AU = (op[2] >> 4) & 0x0f;
11122 #line 751 "rx-decode.opc"
11123                       int rdst AU = op[2] & 0x0f;
11124                       if (trace)
11125                         {
11126                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11127                                  "/** 1111 1101 0110 0110 rsrc rdst     rotl    %1, %0 */",
11128                                  op[0], op[1], op[2]);
11129                           printf ("  rsrc = 0x%x,", rsrc);
11130                           printf ("  rdst = 0x%x\n", rdst);
11131                         }
11132                       SYNTAX("rotl      %1, %0");
11133 #line 751 "rx-decode.opc"
11134                       ID(rotl); SR(rsrc); DR(rdst); F__SZC;
11135
11136                     }
11137                   break;
11138               }
11139             break;
11140           case 0x67:
11141               GETBYTE ();
11142               switch (op[2] & 0x00)
11143               {
11144                 case 0x00:
11145                     {
11146                       /** 1111 1101 0110 0111 rsrc rdst revl    %1, %0 */
11147 #line 763 "rx-decode.opc"
11148                       int rsrc AU = (op[2] >> 4) & 0x0f;
11149 #line 763 "rx-decode.opc"
11150                       int rdst AU = op[2] & 0x0f;
11151                       if (trace)
11152                         {
11153                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11154                                  "/** 1111 1101 0110 0111 rsrc rdst     revl    %1, %0 */",
11155                                  op[0], op[1], op[2]);
11156                           printf ("  rsrc = 0x%x,", rsrc);
11157                           printf ("  rdst = 0x%x\n", rdst);
11158                         }
11159                       SYNTAX("revl      %1, %0");
11160 #line 763 "rx-decode.opc"
11161                       ID(revl); SR(rsrc); DR(rdst);
11162
11163                     /*----------------------------------------------------------------------*/
11164                     /* BRANCH                                                           */
11165
11166                     }
11167                   break;
11168               }
11169             break;
11170           case 0x68:
11171               GETBYTE ();
11172               switch (op[2] & 0x00)
11173               {
11174                 case 0x00:
11175                   op_semantics_94:
11176                     {
11177                       /** 1111 1101 0110 100c rsrc rdst mvtc    %1, %0 */
11178 #line 1014 "rx-decode.opc"
11179                       int c AU = op[1] & 0x01;
11180 #line 1014 "rx-decode.opc"
11181                       int rsrc AU = (op[2] >> 4) & 0x0f;
11182 #line 1014 "rx-decode.opc"
11183                       int rdst AU = op[2] & 0x0f;
11184                       if (trace)
11185                         {
11186                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11187                                  "/** 1111 1101 0110 100c rsrc rdst     mvtc    %1, %0 */",
11188                                  op[0], op[1], op[2]);
11189                           printf ("  c = 0x%x,", c);
11190                           printf ("  rsrc = 0x%x,", rsrc);
11191                           printf ("  rdst = 0x%x\n", rdst);
11192                         }
11193                       SYNTAX("mvtc      %1, %0");
11194 #line 1014 "rx-decode.opc"
11195                       ID(mov); SR(rsrc); DR(c*16+rdst + 16);
11196
11197                     }
11198                   break;
11199               }
11200             break;
11201           case 0x69:
11202               GETBYTE ();
11203               switch (op[2] & 0x00)
11204               {
11205                 case 0x00:
11206                   goto op_semantics_94;
11207                   break;
11208               }
11209             break;
11210           case 0x6a:
11211               GETBYTE ();
11212               switch (op[2] & 0x00)
11213               {
11214                 case 0x00:
11215                   op_semantics_95:
11216                     {
11217                       /** 1111 1101 0110 101s rsrc rdst mvfc    %1, %0 */
11218 #line 1017 "rx-decode.opc"
11219                       int s AU = op[1] & 0x01;
11220 #line 1017 "rx-decode.opc"
11221                       int rsrc AU = (op[2] >> 4) & 0x0f;
11222 #line 1017 "rx-decode.opc"
11223                       int rdst AU = op[2] & 0x0f;
11224                       if (trace)
11225                         {
11226                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11227                                  "/** 1111 1101 0110 101s rsrc rdst     mvfc    %1, %0 */",
11228                                  op[0], op[1], op[2]);
11229                           printf ("  s = 0x%x,", s);
11230                           printf ("  rsrc = 0x%x,", rsrc);
11231                           printf ("  rdst = 0x%x\n", rdst);
11232                         }
11233                       SYNTAX("mvfc      %1, %0");
11234 #line 1017 "rx-decode.opc"
11235                       ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
11236
11237                     /*----------------------------------------------------------------------*/
11238                     /* INTERRUPTS                                                               */
11239
11240                     }
11241                   break;
11242               }
11243             break;
11244           case 0x6b:
11245               GETBYTE ();
11246               switch (op[2] & 0x00)
11247               {
11248                 case 0x00:
11249                   goto op_semantics_95;
11250                   break;
11251               }
11252             break;
11253           case 0x6c:
11254               GETBYTE ();
11255               switch (op[2] & 0x00)
11256               {
11257                 case 0x00:
11258                   op_semantics_96:
11259                     {
11260                       /** 1111 1101 0110 110i mmmm rdst rotr    #%1, %0 */
11261 #line 754 "rx-decode.opc"
11262                       int i AU = op[1] & 0x01;
11263 #line 754 "rx-decode.opc"
11264                       int mmmm AU = (op[2] >> 4) & 0x0f;
11265 #line 754 "rx-decode.opc"
11266                       int rdst AU = op[2] & 0x0f;
11267                       if (trace)
11268                         {
11269                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11270                                  "/** 1111 1101 0110 110i mmmm rdst     rotr    #%1, %0 */",
11271                                  op[0], op[1], op[2]);
11272                           printf ("  i = 0x%x,", i);
11273                           printf ("  mmmm = 0x%x,", mmmm);
11274                           printf ("  rdst = 0x%x\n", rdst);
11275                         }
11276                       SYNTAX("rotr      #%1, %0");
11277 #line 754 "rx-decode.opc"
11278                       ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
11279
11280                     }
11281                   break;
11282               }
11283             break;
11284           case 0x6d:
11285               GETBYTE ();
11286               switch (op[2] & 0x00)
11287               {
11288                 case 0x00:
11289                   goto op_semantics_96;
11290                   break;
11291               }
11292             break;
11293           case 0x6e:
11294               GETBYTE ();
11295               switch (op[2] & 0x00)
11296               {
11297                 case 0x00:
11298                   op_semantics_97:
11299                     {
11300                       /** 1111 1101 0110 111i mmmm rdst rotl    #%1, %0 */
11301 #line 748 "rx-decode.opc"
11302                       int i AU = op[1] & 0x01;
11303 #line 748 "rx-decode.opc"
11304                       int mmmm AU = (op[2] >> 4) & 0x0f;
11305 #line 748 "rx-decode.opc"
11306                       int rdst AU = op[2] & 0x0f;
11307                       if (trace)
11308                         {
11309                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11310                                  "/** 1111 1101 0110 111i mmmm rdst     rotl    #%1, %0 */",
11311                                  op[0], op[1], op[2]);
11312                           printf ("  i = 0x%x,", i);
11313                           printf ("  mmmm = 0x%x,", mmmm);
11314                           printf ("  rdst = 0x%x\n", rdst);
11315                         }
11316                       SYNTAX("rotl      #%1, %0");
11317 #line 748 "rx-decode.opc"
11318                       ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
11319
11320                     }
11321                   break;
11322               }
11323             break;
11324           case 0x6f:
11325               GETBYTE ();
11326               switch (op[2] & 0x00)
11327               {
11328                 case 0x00:
11329                   goto op_semantics_97;
11330                   break;
11331               }
11332             break;
11333           case 0x70:
11334               GETBYTE ();
11335               switch (op[2] & 0xf0)
11336               {
11337                 case 0x20:
11338                   op_semantics_98:
11339                     {
11340                       /** 1111 1101 0111 im00 0010rdst  adc     #%1, %0 */
11341 #line 492 "rx-decode.opc"
11342                       int im AU = (op[1] >> 2) & 0x03;
11343 #line 492 "rx-decode.opc"
11344                       int rdst AU = op[2] & 0x0f;
11345                       if (trace)
11346                         {
11347                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11348                                  "/** 1111 1101 0111 im00 0010rdst      adc     #%1, %0 */",
11349                                  op[0], op[1], op[2]);
11350                           printf ("  im = 0x%x,", im);
11351                           printf ("  rdst = 0x%x\n", rdst);
11352                         }
11353                       SYNTAX("adc       #%1, %0");
11354 #line 492 "rx-decode.opc"
11355                       ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
11356
11357                     }
11358                   break;
11359                 case 0x40:
11360                   op_semantics_99:
11361                     {
11362                       /** 1111 1101 0111 im00 0100rdst  max     #%1, %0 */
11363 #line 574 "rx-decode.opc"
11364                       int im AU = (op[1] >> 2) & 0x03;
11365 #line 574 "rx-decode.opc"
11366                       int rdst AU = op[2] & 0x0f;
11367                       if (trace)
11368                         {
11369                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11370                                  "/** 1111 1101 0111 im00 0100rdst      max     #%1, %0 */",
11371                                  op[0], op[1], op[2]);
11372                           printf ("  im = 0x%x,", im);
11373                           printf ("  rdst = 0x%x\n", rdst);
11374                         }
11375                       SYNTAX("max       #%1, %0");
11376 #line 574 "rx-decode.opc"
11377                       int val = IMMex (im);
11378                       if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
11379                         {
11380                           ID (nop7);
11381                           SYNTAX("nop\t; max\t#0x80000000, r0");
11382                         }
11383                       else
11384                         {
11385                           ID(max);
11386                         }
11387                       DR(rdst); SC(val);
11388
11389                     }
11390                   break;
11391                 case 0x50:
11392                   op_semantics_100:
11393                     {
11394                       /** 1111 1101 0111 im00 0101rdst  min     #%1, %0 */
11395 #line 604 "rx-decode.opc"
11396                       int im AU = (op[1] >> 2) & 0x03;
11397 #line 604 "rx-decode.opc"
11398                       int rdst AU = op[2] & 0x0f;
11399                       if (trace)
11400                         {
11401                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11402                                  "/** 1111 1101 0111 im00 0101rdst      min     #%1, %0 */",
11403                                  op[0], op[1], op[2]);
11404                           printf ("  im = 0x%x,", im);
11405                           printf ("  rdst = 0x%x\n", rdst);
11406                         }
11407                       SYNTAX("min       #%1, %0");
11408 #line 604 "rx-decode.opc"
11409                       ID(min); DR(rdst); SC(IMMex(im));
11410
11411                     }
11412                   break;
11413                 case 0x60:
11414                   op_semantics_101:
11415                     {
11416                       /** 1111 1101 0111 im00 0110rdst  emul    #%1, %0 */
11417 #line 662 "rx-decode.opc"
11418                       int im AU = (op[1] >> 2) & 0x03;
11419 #line 662 "rx-decode.opc"
11420                       int rdst AU = op[2] & 0x0f;
11421                       if (trace)
11422                         {
11423                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11424                                  "/** 1111 1101 0111 im00 0110rdst      emul    #%1, %0 */",
11425                                  op[0], op[1], op[2]);
11426                           printf ("  im = 0x%x,", im);
11427                           printf ("  rdst = 0x%x\n", rdst);
11428                         }
11429                       SYNTAX("emul      #%1, %0");
11430 #line 662 "rx-decode.opc"
11431                       ID(emul); DR(rdst); SC(IMMex(im));
11432
11433                     }
11434                   break;
11435                 case 0x70:
11436                   op_semantics_102:
11437                     {
11438                       /** 1111 1101 0111 im00 0111rdst  emulu   #%1, %0 */
11439 #line 674 "rx-decode.opc"
11440                       int im AU = (op[1] >> 2) & 0x03;
11441 #line 674 "rx-decode.opc"
11442                       int rdst AU = op[2] & 0x0f;
11443                       if (trace)
11444                         {
11445                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11446                                  "/** 1111 1101 0111 im00 0111rdst      emulu   #%1, %0 */",
11447                                  op[0], op[1], op[2]);
11448                           printf ("  im = 0x%x,", im);
11449                           printf ("  rdst = 0x%x\n", rdst);
11450                         }
11451                       SYNTAX("emulu     #%1, %0");
11452 #line 674 "rx-decode.opc"
11453                       ID(emulu); DR(rdst); SC(IMMex(im));
11454
11455                     }
11456                   break;
11457                 case 0x80:
11458                   op_semantics_103:
11459                     {
11460                       /** 1111 1101 0111 im00 1000rdst  div     #%1, %0 */
11461 #line 686 "rx-decode.opc"
11462                       int im AU = (op[1] >> 2) & 0x03;
11463 #line 686 "rx-decode.opc"
11464                       int rdst AU = op[2] & 0x0f;
11465                       if (trace)
11466                         {
11467                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11468                                  "/** 1111 1101 0111 im00 1000rdst      div     #%1, %0 */",
11469                                  op[0], op[1], op[2]);
11470                           printf ("  im = 0x%x,", im);
11471                           printf ("  rdst = 0x%x\n", rdst);
11472                         }
11473                       SYNTAX("div       #%1, %0");
11474 #line 686 "rx-decode.opc"
11475                       ID(div); DR(rdst); SC(IMMex(im)); F_O___;
11476
11477                     }
11478                   break;
11479                 case 0x90:
11480                   op_semantics_104:
11481                     {
11482                       /** 1111 1101 0111 im00 1001rdst  divu    #%1, %0 */
11483 #line 698 "rx-decode.opc"
11484                       int im AU = (op[1] >> 2) & 0x03;
11485 #line 698 "rx-decode.opc"
11486                       int rdst AU = op[2] & 0x0f;
11487                       if (trace)
11488                         {
11489                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11490                                  "/** 1111 1101 0111 im00 1001rdst      divu    #%1, %0 */",
11491                                  op[0], op[1], op[2]);
11492                           printf ("  im = 0x%x,", im);
11493                           printf ("  rdst = 0x%x\n", rdst);
11494                         }
11495                       SYNTAX("divu      #%1, %0");
11496 #line 698 "rx-decode.opc"
11497                       ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
11498
11499                     }
11500                   break;
11501                 case 0xc0:
11502                   op_semantics_105:
11503                     {
11504                       /** 1111 1101 0111 im00 1100rdst  tst     #%1, %2 */
11505 #line 471 "rx-decode.opc"
11506                       int im AU = (op[1] >> 2) & 0x03;
11507 #line 471 "rx-decode.opc"
11508                       int rdst AU = op[2] & 0x0f;
11509                       if (trace)
11510                         {
11511                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11512                                  "/** 1111 1101 0111 im00 1100rdst      tst     #%1, %2 */",
11513                                  op[0], op[1], op[2]);
11514                           printf ("  im = 0x%x,", im);
11515                           printf ("  rdst = 0x%x\n", rdst);
11516                         }
11517                       SYNTAX("tst       #%1, %2");
11518 #line 471 "rx-decode.opc"
11519                       ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
11520
11521                     }
11522                   break;
11523                 case 0xd0:
11524                   op_semantics_106:
11525                     {
11526                       /** 1111 1101 0111 im00 1101rdst  xor     #%1, %0 */
11527 #line 450 "rx-decode.opc"
11528                       int im AU = (op[1] >> 2) & 0x03;
11529 #line 450 "rx-decode.opc"
11530                       int rdst AU = op[2] & 0x0f;
11531                       if (trace)
11532                         {
11533                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11534                                  "/** 1111 1101 0111 im00 1101rdst      xor     #%1, %0 */",
11535                                  op[0], op[1], op[2]);
11536                           printf ("  im = 0x%x,", im);
11537                           printf ("  rdst = 0x%x\n", rdst);
11538                         }
11539                       SYNTAX("xor       #%1, %0");
11540 #line 450 "rx-decode.opc"
11541                       ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
11542
11543                     }
11544                   break;
11545                 case 0xe0:
11546                   op_semantics_107:
11547                     {
11548                       /** 1111 1101 0111 im00 1110rdst  stz     #%1, %0 */
11549 #line 396 "rx-decode.opc"
11550                       int im AU = (op[1] >> 2) & 0x03;
11551 #line 396 "rx-decode.opc"
11552                       int rdst AU = op[2] & 0x0f;
11553                       if (trace)
11554                         {
11555                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11556                                  "/** 1111 1101 0111 im00 1110rdst      stz     #%1, %0 */",
11557                                  op[0], op[1], op[2]);
11558                           printf ("  im = 0x%x,", im);
11559                           printf ("  rdst = 0x%x\n", rdst);
11560                         }
11561                       SYNTAX("stz       #%1, %0");
11562 #line 396 "rx-decode.opc"
11563                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
11564
11565                     }
11566                   break;
11567                 case 0xf0:
11568                   op_semantics_108:
11569                     {
11570                       /** 1111 1101 0111 im00 1111rdst  stnz    #%1, %0 */
11571 #line 399 "rx-decode.opc"
11572                       int im AU = (op[1] >> 2) & 0x03;
11573 #line 399 "rx-decode.opc"
11574                       int rdst AU = op[2] & 0x0f;
11575                       if (trace)
11576                         {
11577                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11578                                  "/** 1111 1101 0111 im00 1111rdst      stnz    #%1, %0 */",
11579                                  op[0], op[1], op[2]);
11580                           printf ("  im = 0x%x,", im);
11581                           printf ("  rdst = 0x%x\n", rdst);
11582                         }
11583                       SYNTAX("stnz      #%1, %0");
11584 #line 399 "rx-decode.opc"
11585                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
11586
11587                     /*----------------------------------------------------------------------*/
11588                     /* RTSD                                                                     */
11589
11590                     }
11591                   break;
11592                 default: UNSUPPORTED(); break;
11593               }
11594             break;
11595           case 0x72:
11596               GETBYTE ();
11597               switch (op[2] & 0xf0)
11598               {
11599                 case 0x00:
11600                     {
11601                       /** 1111 1101 0111 0010 0000 rdst fsub    #%1, %0 */
11602 #line 906 "rx-decode.opc"
11603                       int rdst AU = op[2] & 0x0f;
11604                       if (trace)
11605                         {
11606                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11607                                  "/** 1111 1101 0111 0010 0000 rdst     fsub    #%1, %0 */",
11608                                  op[0], op[1], op[2]);
11609                           printf ("  rdst = 0x%x\n", rdst);
11610                         }
11611                       SYNTAX("fsub      #%1, %0");
11612 #line 906 "rx-decode.opc"
11613                       ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
11614
11615                     }
11616                   break;
11617                 case 0x10:
11618                     {
11619                       /** 1111 1101 0111 0010 0001 rdst fcmp    #%1, %0 */
11620 #line 900 "rx-decode.opc"
11621                       int rdst AU = op[2] & 0x0f;
11622                       if (trace)
11623                         {
11624                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11625                                  "/** 1111 1101 0111 0010 0001 rdst     fcmp    #%1, %0 */",
11626                                  op[0], op[1], op[2]);
11627                           printf ("  rdst = 0x%x\n", rdst);
11628                         }
11629                       SYNTAX("fcmp      #%1, %0");
11630 #line 900 "rx-decode.opc"
11631                       ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
11632
11633                     }
11634                   break;
11635                 case 0x20:
11636                     {
11637                       /** 1111 1101 0111 0010 0010 rdst fadd    #%1, %0 */
11638 #line 894 "rx-decode.opc"
11639                       int rdst AU = op[2] & 0x0f;
11640                       if (trace)
11641                         {
11642                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11643                                  "/** 1111 1101 0111 0010 0010 rdst     fadd    #%1, %0 */",
11644                                  op[0], op[1], op[2]);
11645                           printf ("  rdst = 0x%x\n", rdst);
11646                         }
11647                       SYNTAX("fadd      #%1, %0");
11648 #line 894 "rx-decode.opc"
11649                       ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
11650
11651                     }
11652                   break;
11653                 case 0x30:
11654                     {
11655                       /** 1111 1101 0111 0010 0011 rdst fmul    #%1, %0 */
11656 #line 915 "rx-decode.opc"
11657                       int rdst AU = op[2] & 0x0f;
11658                       if (trace)
11659                         {
11660                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11661                                  "/** 1111 1101 0111 0010 0011 rdst     fmul    #%1, %0 */",
11662                                  op[0], op[1], op[2]);
11663                           printf ("  rdst = 0x%x\n", rdst);
11664                         }
11665                       SYNTAX("fmul      #%1, %0");
11666 #line 915 "rx-decode.opc"
11667                       ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
11668
11669                     }
11670                   break;
11671                 case 0x40:
11672                     {
11673                       /** 1111 1101 0111 0010 0100 rdst fdiv    #%1, %0 */
11674 #line 921 "rx-decode.opc"
11675                       int rdst AU = op[2] & 0x0f;
11676                       if (trace)
11677                         {
11678                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11679                                  "/** 1111 1101 0111 0010 0100 rdst     fdiv    #%1, %0 */",
11680                                  op[0], op[1], op[2]);
11681                           printf ("  rdst = 0x%x\n", rdst);
11682                         }
11683                       SYNTAX("fdiv      #%1, %0");
11684 #line 921 "rx-decode.opc"
11685                       ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
11686
11687                     }
11688                   break;
11689                 default: UNSUPPORTED(); break;
11690               }
11691             break;
11692           case 0x73:
11693               GETBYTE ();
11694               switch (op[2] & 0xe0)
11695               {
11696                 case 0x00:
11697                   op_semantics_109:
11698                     {
11699                       /** 1111 1101 0111 im11 000crdst  mvtc    #%1, %0 */
11700 #line 1011 "rx-decode.opc"
11701                       int im AU = (op[1] >> 2) & 0x03;
11702 #line 1011 "rx-decode.opc"
11703                       int crdst AU = op[2] & 0x1f;
11704                       if (trace)
11705                         {
11706                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11707                                  "/** 1111 1101 0111 im11 000crdst      mvtc    #%1, %0 */",
11708                                  op[0], op[1], op[2]);
11709                           printf ("  im = 0x%x,", im);
11710                           printf ("  crdst = 0x%x\n", crdst);
11711                         }
11712                       SYNTAX("mvtc      #%1, %0");
11713 #line 1011 "rx-decode.opc"
11714                       ID(mov); SC(IMMex(im)); DR(crdst + 16);
11715
11716                     }
11717                   break;
11718                 default: UNSUPPORTED(); break;
11719               }
11720             break;
11721           case 0x74:
11722               GETBYTE ();
11723               switch (op[2] & 0xf0)
11724               {
11725                 case 0x20:
11726                   goto op_semantics_98;
11727                   break;
11728                 case 0x40:
11729                   goto op_semantics_99;
11730                   break;
11731                 case 0x50:
11732                   goto op_semantics_100;
11733                   break;
11734                 case 0x60:
11735                   goto op_semantics_101;
11736                   break;
11737                 case 0x70:
11738                   goto op_semantics_102;
11739                   break;
11740                 case 0x80:
11741                   goto op_semantics_103;
11742                   break;
11743                 case 0x90:
11744                   goto op_semantics_104;
11745                   break;
11746                 case 0xc0:
11747                   goto op_semantics_105;
11748                   break;
11749                 case 0xd0:
11750                   goto op_semantics_106;
11751                   break;
11752                 case 0xe0:
11753                   goto op_semantics_107;
11754                   break;
11755                 case 0xf0:
11756                   goto op_semantics_108;
11757                   break;
11758                 default: UNSUPPORTED(); break;
11759               }
11760             break;
11761           case 0x77:
11762               GETBYTE ();
11763               switch (op[2] & 0xe0)
11764               {
11765                 case 0x00:
11766                   goto op_semantics_109;
11767                   break;
11768                 default: UNSUPPORTED(); break;
11769               }
11770             break;
11771           case 0x78:
11772               GETBYTE ();
11773               switch (op[2] & 0xf0)
11774               {
11775                 case 0x20:
11776                   goto op_semantics_98;
11777                   break;
11778                 case 0x40:
11779                   goto op_semantics_99;
11780                   break;
11781                 case 0x50:
11782                   goto op_semantics_100;
11783                   break;
11784                 case 0x60:
11785                   goto op_semantics_101;
11786                   break;
11787                 case 0x70:
11788                   goto op_semantics_102;
11789                   break;
11790                 case 0x80:
11791                   goto op_semantics_103;
11792                   break;
11793                 case 0x90:
11794                   goto op_semantics_104;
11795                   break;
11796                 case 0xc0:
11797                   goto op_semantics_105;
11798                   break;
11799                 case 0xd0:
11800                   goto op_semantics_106;
11801                   break;
11802                 case 0xe0:
11803                   goto op_semantics_107;
11804                   break;
11805                 case 0xf0:
11806                   goto op_semantics_108;
11807                   break;
11808                 default: UNSUPPORTED(); break;
11809               }
11810             break;
11811           case 0x7b:
11812               GETBYTE ();
11813               switch (op[2] & 0xe0)
11814               {
11815                 case 0x00:
11816                   goto op_semantics_109;
11817                   break;
11818                 default: UNSUPPORTED(); break;
11819               }
11820             break;
11821           case 0x7c:
11822               GETBYTE ();
11823               switch (op[2] & 0xf0)
11824               {
11825                 case 0x20:
11826                   goto op_semantics_98;
11827                   break;
11828                 case 0x40:
11829                   goto op_semantics_99;
11830                   break;
11831                 case 0x50:
11832                   goto op_semantics_100;
11833                   break;
11834                 case 0x60:
11835                   goto op_semantics_101;
11836                   break;
11837                 case 0x70:
11838                   goto op_semantics_102;
11839                   break;
11840                 case 0x80:
11841                   goto op_semantics_103;
11842                   break;
11843                 case 0x90:
11844                   goto op_semantics_104;
11845                   break;
11846                 case 0xc0:
11847                   goto op_semantics_105;
11848                   break;
11849                 case 0xd0:
11850                   goto op_semantics_106;
11851                   break;
11852                 case 0xe0:
11853                   goto op_semantics_107;
11854                   break;
11855                 case 0xf0:
11856                   goto op_semantics_108;
11857                   break;
11858                 default: UNSUPPORTED(); break;
11859               }
11860             break;
11861           case 0x7f:
11862               GETBYTE ();
11863               switch (op[2] & 0xe0)
11864               {
11865                 case 0x00:
11866                   goto op_semantics_109;
11867                   break;
11868                 default: UNSUPPORTED(); break;
11869               }
11870             break;
11871           case 0x80:
11872               GETBYTE ();
11873               switch (op[2] & 0x00)
11874               {
11875                 case 0x00:
11876                   op_semantics_110:
11877                     {
11878                       /** 1111 1101 100immmm rsrc rdst  shlr    #%2, %1, %0 */
11879 #line 736 "rx-decode.opc"
11880                       int immmm AU = op[1] & 0x1f;
11881 #line 736 "rx-decode.opc"
11882                       int rsrc AU = (op[2] >> 4) & 0x0f;
11883 #line 736 "rx-decode.opc"
11884                       int rdst AU = op[2] & 0x0f;
11885                       if (trace)
11886                         {
11887                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11888                                  "/** 1111 1101 100immmm rsrc rdst      shlr    #%2, %1, %0 */",
11889                                  op[0], op[1], op[2]);
11890                           printf ("  immmm = 0x%x,", immmm);
11891                           printf ("  rsrc = 0x%x,", rsrc);
11892                           printf ("  rdst = 0x%x\n", rdst);
11893                         }
11894                       SYNTAX("shlr      #%2, %1, %0");
11895 #line 736 "rx-decode.opc"
11896                       ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
11897
11898                     /*----------------------------------------------------------------------*/
11899                     /* ROTATE                                                           */
11900
11901                     }
11902                   break;
11903               }
11904             break;
11905           case 0x81:
11906               GETBYTE ();
11907               switch (op[2] & 0x00)
11908               {
11909                 case 0x00:
11910                   goto op_semantics_110;
11911                   break;
11912               }
11913             break;
11914           case 0x82:
11915               GETBYTE ();
11916               switch (op[2] & 0x00)
11917               {
11918                 case 0x00:
11919                   goto op_semantics_110;
11920                   break;
11921               }
11922             break;
11923           case 0x83:
11924               GETBYTE ();
11925               switch (op[2] & 0x00)
11926               {
11927                 case 0x00:
11928                   goto op_semantics_110;
11929                   break;
11930               }
11931             break;
11932           case 0x84:
11933               GETBYTE ();
11934               switch (op[2] & 0x00)
11935               {
11936                 case 0x00:
11937                   goto op_semantics_110;
11938                   break;
11939               }
11940             break;
11941           case 0x85:
11942               GETBYTE ();
11943               switch (op[2] & 0x00)
11944               {
11945                 case 0x00:
11946                   goto op_semantics_110;
11947                   break;
11948               }
11949             break;
11950           case 0x86:
11951               GETBYTE ();
11952               switch (op[2] & 0x00)
11953               {
11954                 case 0x00:
11955                   goto op_semantics_110;
11956                   break;
11957               }
11958             break;
11959           case 0x87:
11960               GETBYTE ();
11961               switch (op[2] & 0x00)
11962               {
11963                 case 0x00:
11964                   goto op_semantics_110;
11965                   break;
11966               }
11967             break;
11968           case 0x88:
11969               GETBYTE ();
11970               switch (op[2] & 0x00)
11971               {
11972                 case 0x00:
11973                   goto op_semantics_110;
11974                   break;
11975               }
11976             break;
11977           case 0x89:
11978               GETBYTE ();
11979               switch (op[2] & 0x00)
11980               {
11981                 case 0x00:
11982                   goto op_semantics_110;
11983                   break;
11984               }
11985             break;
11986           case 0x8a:
11987               GETBYTE ();
11988               switch (op[2] & 0x00)
11989               {
11990                 case 0x00:
11991                   goto op_semantics_110;
11992                   break;
11993               }
11994             break;
11995           case 0x8b:
11996               GETBYTE ();
11997               switch (op[2] & 0x00)
11998               {
11999                 case 0x00:
12000                   goto op_semantics_110;
12001                   break;
12002               }
12003             break;
12004           case 0x8c:
12005               GETBYTE ();
12006               switch (op[2] & 0x00)
12007               {
12008                 case 0x00:
12009                   goto op_semantics_110;
12010                   break;
12011               }
12012             break;
12013           case 0x8d:
12014               GETBYTE ();
12015               switch (op[2] & 0x00)
12016               {
12017                 case 0x00:
12018                   goto op_semantics_110;
12019                   break;
12020               }
12021             break;
12022           case 0x8e:
12023               GETBYTE ();
12024               switch (op[2] & 0x00)
12025               {
12026                 case 0x00:
12027                   goto op_semantics_110;
12028                   break;
12029               }
12030             break;
12031           case 0x8f:
12032               GETBYTE ();
12033               switch (op[2] & 0x00)
12034               {
12035                 case 0x00:
12036                   goto op_semantics_110;
12037                   break;
12038               }
12039             break;
12040           case 0x90:
12041               GETBYTE ();
12042               switch (op[2] & 0x00)
12043               {
12044                 case 0x00:
12045                   goto op_semantics_110;
12046                   break;
12047               }
12048             break;
12049           case 0x91:
12050               GETBYTE ();
12051               switch (op[2] & 0x00)
12052               {
12053                 case 0x00:
12054                   goto op_semantics_110;
12055                   break;
12056               }
12057             break;
12058           case 0x92:
12059               GETBYTE ();
12060               switch (op[2] & 0x00)
12061               {
12062                 case 0x00:
12063                   goto op_semantics_110;
12064                   break;
12065               }
12066             break;
12067           case 0x93:
12068               GETBYTE ();
12069               switch (op[2] & 0x00)
12070               {
12071                 case 0x00:
12072                   goto op_semantics_110;
12073                   break;
12074               }
12075             break;
12076           case 0x94:
12077               GETBYTE ();
12078               switch (op[2] & 0x00)
12079               {
12080                 case 0x00:
12081                   goto op_semantics_110;
12082                   break;
12083               }
12084             break;
12085           case 0x95:
12086               GETBYTE ();
12087               switch (op[2] & 0x00)
12088               {
12089                 case 0x00:
12090                   goto op_semantics_110;
12091                   break;
12092               }
12093             break;
12094           case 0x96:
12095               GETBYTE ();
12096               switch (op[2] & 0x00)
12097               {
12098                 case 0x00:
12099                   goto op_semantics_110;
12100                   break;
12101               }
12102             break;
12103           case 0x97:
12104               GETBYTE ();
12105               switch (op[2] & 0x00)
12106               {
12107                 case 0x00:
12108                   goto op_semantics_110;
12109                   break;
12110               }
12111             break;
12112           case 0x98:
12113               GETBYTE ();
12114               switch (op[2] & 0x00)
12115               {
12116                 case 0x00:
12117                   goto op_semantics_110;
12118                   break;
12119               }
12120             break;
12121           case 0x99:
12122               GETBYTE ();
12123               switch (op[2] & 0x00)
12124               {
12125                 case 0x00:
12126                   goto op_semantics_110;
12127                   break;
12128               }
12129             break;
12130           case 0x9a:
12131               GETBYTE ();
12132               switch (op[2] & 0x00)
12133               {
12134                 case 0x00:
12135                   goto op_semantics_110;
12136                   break;
12137               }
12138             break;
12139           case 0x9b:
12140               GETBYTE ();
12141               switch (op[2] & 0x00)
12142               {
12143                 case 0x00:
12144                   goto op_semantics_110;
12145                   break;
12146               }
12147             break;
12148           case 0x9c:
12149               GETBYTE ();
12150               switch (op[2] & 0x00)
12151               {
12152                 case 0x00:
12153                   goto op_semantics_110;
12154                   break;
12155               }
12156             break;
12157           case 0x9d:
12158               GETBYTE ();
12159               switch (op[2] & 0x00)
12160               {
12161                 case 0x00:
12162                   goto op_semantics_110;
12163                   break;
12164               }
12165             break;
12166           case 0x9e:
12167               GETBYTE ();
12168               switch (op[2] & 0x00)
12169               {
12170                 case 0x00:
12171                   goto op_semantics_110;
12172                   break;
12173               }
12174             break;
12175           case 0x9f:
12176               GETBYTE ();
12177               switch (op[2] & 0x00)
12178               {
12179                 case 0x00:
12180                   goto op_semantics_110;
12181                   break;
12182               }
12183             break;
12184           case 0xa0:
12185               GETBYTE ();
12186               switch (op[2] & 0x00)
12187               {
12188                 case 0x00:
12189                   op_semantics_111:
12190                     {
12191                       /** 1111 1101 101immmm rsrc rdst  shar    #%2, %1, %0 */
12192 #line 726 "rx-decode.opc"
12193                       int immmm AU = op[1] & 0x1f;
12194 #line 726 "rx-decode.opc"
12195                       int rsrc AU = (op[2] >> 4) & 0x0f;
12196 #line 726 "rx-decode.opc"
12197                       int rdst AU = op[2] & 0x0f;
12198                       if (trace)
12199                         {
12200                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12201                                  "/** 1111 1101 101immmm rsrc rdst      shar    #%2, %1, %0 */",
12202                                  op[0], op[1], op[2]);
12203                           printf ("  immmm = 0x%x,", immmm);
12204                           printf ("  rsrc = 0x%x,", rsrc);
12205                           printf ("  rdst = 0x%x\n", rdst);
12206                         }
12207                       SYNTAX("shar      #%2, %1, %0");
12208 #line 726 "rx-decode.opc"
12209                       ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
12210
12211
12212                     }
12213                   break;
12214               }
12215             break;
12216           case 0xa1:
12217               GETBYTE ();
12218               switch (op[2] & 0x00)
12219               {
12220                 case 0x00:
12221                   goto op_semantics_111;
12222                   break;
12223               }
12224             break;
12225           case 0xa2:
12226               GETBYTE ();
12227               switch (op[2] & 0x00)
12228               {
12229                 case 0x00:
12230                   goto op_semantics_111;
12231                   break;
12232               }
12233             break;
12234           case 0xa3:
12235               GETBYTE ();
12236               switch (op[2] & 0x00)
12237               {
12238                 case 0x00:
12239                   goto op_semantics_111;
12240                   break;
12241               }
12242             break;
12243           case 0xa4:
12244               GETBYTE ();
12245               switch (op[2] & 0x00)
12246               {
12247                 case 0x00:
12248                   goto op_semantics_111;
12249                   break;
12250               }
12251             break;
12252           case 0xa5:
12253               GETBYTE ();
12254               switch (op[2] & 0x00)
12255               {
12256                 case 0x00:
12257                   goto op_semantics_111;
12258                   break;
12259               }
12260             break;
12261           case 0xa6:
12262               GETBYTE ();
12263               switch (op[2] & 0x00)
12264               {
12265                 case 0x00:
12266                   goto op_semantics_111;
12267                   break;
12268               }
12269             break;
12270           case 0xa7:
12271               GETBYTE ();
12272               switch (op[2] & 0x00)
12273               {
12274                 case 0x00:
12275                   goto op_semantics_111;
12276                   break;
12277               }
12278             break;
12279           case 0xa8:
12280               GETBYTE ();
12281               switch (op[2] & 0x00)
12282               {
12283                 case 0x00:
12284                   goto op_semantics_111;
12285                   break;
12286               }
12287             break;
12288           case 0xa9:
12289               GETBYTE ();
12290               switch (op[2] & 0x00)
12291               {
12292                 case 0x00:
12293                   goto op_semantics_111;
12294                   break;
12295               }
12296             break;
12297           case 0xaa:
12298               GETBYTE ();
12299               switch (op[2] & 0x00)
12300               {
12301                 case 0x00:
12302                   goto op_semantics_111;
12303                   break;
12304               }
12305             break;
12306           case 0xab:
12307               GETBYTE ();
12308               switch (op[2] & 0x00)
12309               {
12310                 case 0x00:
12311                   goto op_semantics_111;
12312                   break;
12313               }
12314             break;
12315           case 0xac:
12316               GETBYTE ();
12317               switch (op[2] & 0x00)
12318               {
12319                 case 0x00:
12320                   goto op_semantics_111;
12321                   break;
12322               }
12323             break;
12324           case 0xad:
12325               GETBYTE ();
12326               switch (op[2] & 0x00)
12327               {
12328                 case 0x00:
12329                   goto op_semantics_111;
12330                   break;
12331               }
12332             break;
12333           case 0xae:
12334               GETBYTE ();
12335               switch (op[2] & 0x00)
12336               {
12337                 case 0x00:
12338                   goto op_semantics_111;
12339                   break;
12340               }
12341             break;
12342           case 0xaf:
12343               GETBYTE ();
12344               switch (op[2] & 0x00)
12345               {
12346                 case 0x00:
12347                   goto op_semantics_111;
12348                   break;
12349               }
12350             break;
12351           case 0xb0:
12352               GETBYTE ();
12353               switch (op[2] & 0x00)
12354               {
12355                 case 0x00:
12356                   goto op_semantics_111;
12357                   break;
12358               }
12359             break;
12360           case 0xb1:
12361               GETBYTE ();
12362               switch (op[2] & 0x00)
12363               {
12364                 case 0x00:
12365                   goto op_semantics_111;
12366                   break;
12367               }
12368             break;
12369           case 0xb2:
12370               GETBYTE ();
12371               switch (op[2] & 0x00)
12372               {
12373                 case 0x00:
12374                   goto op_semantics_111;
12375                   break;
12376               }
12377             break;
12378           case 0xb3:
12379               GETBYTE ();
12380               switch (op[2] & 0x00)
12381               {
12382                 case 0x00:
12383                   goto op_semantics_111;
12384                   break;
12385               }
12386             break;
12387           case 0xb4:
12388               GETBYTE ();
12389               switch (op[2] & 0x00)
12390               {
12391                 case 0x00:
12392                   goto op_semantics_111;
12393                   break;
12394               }
12395             break;
12396           case 0xb5:
12397               GETBYTE ();
12398               switch (op[2] & 0x00)
12399               {
12400                 case 0x00:
12401                   goto op_semantics_111;
12402                   break;
12403               }
12404             break;
12405           case 0xb6:
12406               GETBYTE ();
12407               switch (op[2] & 0x00)
12408               {
12409                 case 0x00:
12410                   goto op_semantics_111;
12411                   break;
12412               }
12413             break;
12414           case 0xb7:
12415               GETBYTE ();
12416               switch (op[2] & 0x00)
12417               {
12418                 case 0x00:
12419                   goto op_semantics_111;
12420                   break;
12421               }
12422             break;
12423           case 0xb8:
12424               GETBYTE ();
12425               switch (op[2] & 0x00)
12426               {
12427                 case 0x00:
12428                   goto op_semantics_111;
12429                   break;
12430               }
12431             break;
12432           case 0xb9:
12433               GETBYTE ();
12434               switch (op[2] & 0x00)
12435               {
12436                 case 0x00:
12437                   goto op_semantics_111;
12438                   break;
12439               }
12440             break;
12441           case 0xba:
12442               GETBYTE ();
12443               switch (op[2] & 0x00)
12444               {
12445                 case 0x00:
12446                   goto op_semantics_111;
12447                   break;
12448               }
12449             break;
12450           case 0xbb:
12451               GETBYTE ();
12452               switch (op[2] & 0x00)
12453               {
12454                 case 0x00:
12455                   goto op_semantics_111;
12456                   break;
12457               }
12458             break;
12459           case 0xbc:
12460               GETBYTE ();
12461               switch (op[2] & 0x00)
12462               {
12463                 case 0x00:
12464                   goto op_semantics_111;
12465                   break;
12466               }
12467             break;
12468           case 0xbd:
12469               GETBYTE ();
12470               switch (op[2] & 0x00)
12471               {
12472                 case 0x00:
12473                   goto op_semantics_111;
12474                   break;
12475               }
12476             break;
12477           case 0xbe:
12478               GETBYTE ();
12479               switch (op[2] & 0x00)
12480               {
12481                 case 0x00:
12482                   goto op_semantics_111;
12483                   break;
12484               }
12485             break;
12486           case 0xbf:
12487               GETBYTE ();
12488               switch (op[2] & 0x00)
12489               {
12490                 case 0x00:
12491                   goto op_semantics_111;
12492                   break;
12493               }
12494             break;
12495           case 0xc0:
12496               GETBYTE ();
12497               switch (op[2] & 0x00)
12498               {
12499                 case 0x00:
12500                   op_semantics_112:
12501                     {
12502                       /** 1111 1101 110immmm rsrc rdst  shll    #%2, %1, %0 */
12503 #line 716 "rx-decode.opc"
12504                       int immmm AU = op[1] & 0x1f;
12505 #line 716 "rx-decode.opc"
12506                       int rsrc AU = (op[2] >> 4) & 0x0f;
12507 #line 716 "rx-decode.opc"
12508                       int rdst AU = op[2] & 0x0f;
12509                       if (trace)
12510                         {
12511                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12512                                  "/** 1111 1101 110immmm rsrc rdst      shll    #%2, %1, %0 */",
12513                                  op[0], op[1], op[2]);
12514                           printf ("  immmm = 0x%x,", immmm);
12515                           printf ("  rsrc = 0x%x,", rsrc);
12516                           printf ("  rdst = 0x%x\n", rdst);
12517                         }
12518                       SYNTAX("shll      #%2, %1, %0");
12519 #line 716 "rx-decode.opc"
12520                       ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
12521
12522
12523                     }
12524                   break;
12525               }
12526             break;
12527           case 0xc1:
12528               GETBYTE ();
12529               switch (op[2] & 0x00)
12530               {
12531                 case 0x00:
12532                   goto op_semantics_112;
12533                   break;
12534               }
12535             break;
12536           case 0xc2:
12537               GETBYTE ();
12538               switch (op[2] & 0x00)
12539               {
12540                 case 0x00:
12541                   goto op_semantics_112;
12542                   break;
12543               }
12544             break;
12545           case 0xc3:
12546               GETBYTE ();
12547               switch (op[2] & 0x00)
12548               {
12549                 case 0x00:
12550                   goto op_semantics_112;
12551                   break;
12552               }
12553             break;
12554           case 0xc4:
12555               GETBYTE ();
12556               switch (op[2] & 0x00)
12557               {
12558                 case 0x00:
12559                   goto op_semantics_112;
12560                   break;
12561               }
12562             break;
12563           case 0xc5:
12564               GETBYTE ();
12565               switch (op[2] & 0x00)
12566               {
12567                 case 0x00:
12568                   goto op_semantics_112;
12569                   break;
12570               }
12571             break;
12572           case 0xc6:
12573               GETBYTE ();
12574               switch (op[2] & 0x00)
12575               {
12576                 case 0x00:
12577                   goto op_semantics_112;
12578                   break;
12579               }
12580             break;
12581           case 0xc7:
12582               GETBYTE ();
12583               switch (op[2] & 0x00)
12584               {
12585                 case 0x00:
12586                   goto op_semantics_112;
12587                   break;
12588               }
12589             break;
12590           case 0xc8:
12591               GETBYTE ();
12592               switch (op[2] & 0x00)
12593               {
12594                 case 0x00:
12595                   goto op_semantics_112;
12596                   break;
12597               }
12598             break;
12599           case 0xc9:
12600               GETBYTE ();
12601               switch (op[2] & 0x00)
12602               {
12603                 case 0x00:
12604                   goto op_semantics_112;
12605                   break;
12606               }
12607             break;
12608           case 0xca:
12609               GETBYTE ();
12610               switch (op[2] & 0x00)
12611               {
12612                 case 0x00:
12613                   goto op_semantics_112;
12614                   break;
12615               }
12616             break;
12617           case 0xcb:
12618               GETBYTE ();
12619               switch (op[2] & 0x00)
12620               {
12621                 case 0x00:
12622                   goto op_semantics_112;
12623                   break;
12624               }
12625             break;
12626           case 0xcc:
12627               GETBYTE ();
12628               switch (op[2] & 0x00)
12629               {
12630                 case 0x00:
12631                   goto op_semantics_112;
12632                   break;
12633               }
12634             break;
12635           case 0xcd:
12636               GETBYTE ();
12637               switch (op[2] & 0x00)
12638               {
12639                 case 0x00:
12640                   goto op_semantics_112;
12641                   break;
12642               }
12643             break;
12644           case 0xce:
12645               GETBYTE ();
12646               switch (op[2] & 0x00)
12647               {
12648                 case 0x00:
12649                   goto op_semantics_112;
12650                   break;
12651               }
12652             break;
12653           case 0xcf:
12654               GETBYTE ();
12655               switch (op[2] & 0x00)
12656               {
12657                 case 0x00:
12658                   goto op_semantics_112;
12659                   break;
12660               }
12661             break;
12662           case 0xd0:
12663               GETBYTE ();
12664               switch (op[2] & 0x00)
12665               {
12666                 case 0x00:
12667                   goto op_semantics_112;
12668                   break;
12669               }
12670             break;
12671           case 0xd1:
12672               GETBYTE ();
12673               switch (op[2] & 0x00)
12674               {
12675                 case 0x00:
12676                   goto op_semantics_112;
12677                   break;
12678               }
12679             break;
12680           case 0xd2:
12681               GETBYTE ();
12682               switch (op[2] & 0x00)
12683               {
12684                 case 0x00:
12685                   goto op_semantics_112;
12686                   break;
12687               }
12688             break;
12689           case 0xd3:
12690               GETBYTE ();
12691               switch (op[2] & 0x00)
12692               {
12693                 case 0x00:
12694                   goto op_semantics_112;
12695                   break;
12696               }
12697             break;
12698           case 0xd4:
12699               GETBYTE ();
12700               switch (op[2] & 0x00)
12701               {
12702                 case 0x00:
12703                   goto op_semantics_112;
12704                   break;
12705               }
12706             break;
12707           case 0xd5:
12708               GETBYTE ();
12709               switch (op[2] & 0x00)
12710               {
12711                 case 0x00:
12712                   goto op_semantics_112;
12713                   break;
12714               }
12715             break;
12716           case 0xd6:
12717               GETBYTE ();
12718               switch (op[2] & 0x00)
12719               {
12720                 case 0x00:
12721                   goto op_semantics_112;
12722                   break;
12723               }
12724             break;
12725           case 0xd7:
12726               GETBYTE ();
12727               switch (op[2] & 0x00)
12728               {
12729                 case 0x00:
12730                   goto op_semantics_112;
12731                   break;
12732               }
12733             break;
12734           case 0xd8:
12735               GETBYTE ();
12736               switch (op[2] & 0x00)
12737               {
12738                 case 0x00:
12739                   goto op_semantics_112;
12740                   break;
12741               }
12742             break;
12743           case 0xd9:
12744               GETBYTE ();
12745               switch (op[2] & 0x00)
12746               {
12747                 case 0x00:
12748                   goto op_semantics_112;
12749                   break;
12750               }
12751             break;
12752           case 0xda:
12753               GETBYTE ();
12754               switch (op[2] & 0x00)
12755               {
12756                 case 0x00:
12757                   goto op_semantics_112;
12758                   break;
12759               }
12760             break;
12761           case 0xdb:
12762               GETBYTE ();
12763               switch (op[2] & 0x00)
12764               {
12765                 case 0x00:
12766                   goto op_semantics_112;
12767                   break;
12768               }
12769             break;
12770           case 0xdc:
12771               GETBYTE ();
12772               switch (op[2] & 0x00)
12773               {
12774                 case 0x00:
12775                   goto op_semantics_112;
12776                   break;
12777               }
12778             break;
12779           case 0xdd:
12780               GETBYTE ();
12781               switch (op[2] & 0x00)
12782               {
12783                 case 0x00:
12784                   goto op_semantics_112;
12785                   break;
12786               }
12787             break;
12788           case 0xde:
12789               GETBYTE ();
12790               switch (op[2] & 0x00)
12791               {
12792                 case 0x00:
12793                   goto op_semantics_112;
12794                   break;
12795               }
12796             break;
12797           case 0xdf:
12798               GETBYTE ();
12799               switch (op[2] & 0x00)
12800               {
12801                 case 0x00:
12802                   goto op_semantics_112;
12803                   break;
12804               }
12805             break;
12806           case 0xe0:
12807               GETBYTE ();
12808               switch (op[2] & 0xf0)
12809               {
12810                 case 0x00:
12811                 case 0x10:
12812                 case 0x20:
12813                 case 0x30:
12814                 case 0x40:
12815                 case 0x50:
12816                 case 0x60:
12817                 case 0x70:
12818                 case 0x80:
12819                 case 0x90:
12820                 case 0xa0:
12821                 case 0xb0:
12822                 case 0xc0:
12823                 case 0xd0:
12824                 case 0xe0:
12825                   op_semantics_113:
12826                     {
12827                       /** 1111 1101 111 bittt cond rdst bm%2    #%1, %0%S0 */
12828 #line 990 "rx-decode.opc"
12829                       int bittt AU = op[1] & 0x1f;
12830 #line 990 "rx-decode.opc"
12831                       int cond AU = (op[2] >> 4) & 0x0f;
12832 #line 990 "rx-decode.opc"
12833                       int rdst AU = op[2] & 0x0f;
12834                       if (trace)
12835                         {
12836                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12837                                  "/** 1111 1101 111 bittt cond rdst     bm%2    #%1, %0%S0 */",
12838                                  op[0], op[1], op[2]);
12839                           printf ("  bittt = 0x%x,", bittt);
12840                           printf ("  cond = 0x%x,", cond);
12841                           printf ("  rdst = 0x%x\n", rdst);
12842                         }
12843                       SYNTAX("bm%2      #%1, %0%S0");
12844 #line 990 "rx-decode.opc"
12845                       ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
12846
12847                     /*----------------------------------------------------------------------*/
12848                     /* CONTROL REGISTERS                                                        */
12849
12850                     }
12851                   break;
12852                 case 0xf0:
12853                   op_semantics_114:
12854                     {
12855                       /** 1111 1101 111bittt 1111 rdst  bnot    #%1, %0 */
12856 #line 983 "rx-decode.opc"
12857                       int bittt AU = op[1] & 0x1f;
12858 #line 983 "rx-decode.opc"
12859                       int rdst AU = op[2] & 0x0f;
12860                       if (trace)
12861                         {
12862                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12863                                  "/** 1111 1101 111bittt 1111 rdst      bnot    #%1, %0 */",
12864                                  op[0], op[1], op[2]);
12865                           printf ("  bittt = 0x%x,", bittt);
12866                           printf ("  rdst = 0x%x\n", rdst);
12867                         }
12868                       SYNTAX("bnot      #%1, %0");
12869 #line 983 "rx-decode.opc"
12870                       ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
12871
12872
12873                     }
12874                   break;
12875               }
12876             break;
12877           case 0xe1:
12878               GETBYTE ();
12879               switch (op[2] & 0xf0)
12880               {
12881                 case 0x00:
12882                 case 0x10:
12883                 case 0x20:
12884                 case 0x30:
12885                 case 0x40:
12886                 case 0x50:
12887                 case 0x60:
12888                 case 0x70:
12889                 case 0x80:
12890                 case 0x90:
12891                 case 0xa0:
12892                 case 0xb0:
12893                 case 0xc0:
12894                 case 0xd0:
12895                 case 0xe0:
12896                   goto op_semantics_113;
12897                   break;
12898                 case 0xf0:
12899                   goto op_semantics_114;
12900                   break;
12901               }
12902             break;
12903           case 0xe2:
12904               GETBYTE ();
12905               switch (op[2] & 0xf0)
12906               {
12907                 case 0x00:
12908                 case 0x10:
12909                 case 0x20:
12910                 case 0x30:
12911                 case 0x40:
12912                 case 0x50:
12913                 case 0x60:
12914                 case 0x70:
12915                 case 0x80:
12916                 case 0x90:
12917                 case 0xa0:
12918                 case 0xb0:
12919                 case 0xc0:
12920                 case 0xd0:
12921                 case 0xe0:
12922                   goto op_semantics_113;
12923                   break;
12924                 case 0xf0:
12925                   goto op_semantics_114;
12926                   break;
12927               }
12928             break;
12929           case 0xe3:
12930               GETBYTE ();
12931               switch (op[2] & 0xf0)
12932               {
12933                 case 0x00:
12934                 case 0x10:
12935                 case 0x20:
12936                 case 0x30:
12937                 case 0x40:
12938                 case 0x50:
12939                 case 0x60:
12940                 case 0x70:
12941                 case 0x80:
12942                 case 0x90:
12943                 case 0xa0:
12944                 case 0xb0:
12945                 case 0xc0:
12946                 case 0xd0:
12947                 case 0xe0:
12948                   goto op_semantics_113;
12949                   break;
12950                 case 0xf0:
12951                   goto op_semantics_114;
12952                   break;
12953               }
12954             break;
12955           case 0xe4:
12956               GETBYTE ();
12957               switch (op[2] & 0xf0)
12958               {
12959                 case 0x00:
12960                 case 0x10:
12961                 case 0x20:
12962                 case 0x30:
12963                 case 0x40:
12964                 case 0x50:
12965                 case 0x60:
12966                 case 0x70:
12967                 case 0x80:
12968                 case 0x90:
12969                 case 0xa0:
12970                 case 0xb0:
12971                 case 0xc0:
12972                 case 0xd0:
12973                 case 0xe0:
12974                   goto op_semantics_113;
12975                   break;
12976                 case 0xf0:
12977                   goto op_semantics_114;
12978                   break;
12979               }
12980             break;
12981           case 0xe5:
12982               GETBYTE ();
12983               switch (op[2] & 0xf0)
12984               {
12985                 case 0x00:
12986                 case 0x10:
12987                 case 0x20:
12988                 case 0x30:
12989                 case 0x40:
12990                 case 0x50:
12991                 case 0x60:
12992                 case 0x70:
12993                 case 0x80:
12994                 case 0x90:
12995                 case 0xa0:
12996                 case 0xb0:
12997                 case 0xc0:
12998                 case 0xd0:
12999                 case 0xe0:
13000                   goto op_semantics_113;
13001                   break;
13002                 case 0xf0:
13003                   goto op_semantics_114;
13004                   break;
13005               }
13006             break;
13007           case 0xe6:
13008               GETBYTE ();
13009               switch (op[2] & 0xf0)
13010               {
13011                 case 0x00:
13012                 case 0x10:
13013                 case 0x20:
13014                 case 0x30:
13015                 case 0x40:
13016                 case 0x50:
13017                 case 0x60:
13018                 case 0x70:
13019                 case 0x80:
13020                 case 0x90:
13021                 case 0xa0:
13022                 case 0xb0:
13023                 case 0xc0:
13024                 case 0xd0:
13025                 case 0xe0:
13026                   goto op_semantics_113;
13027                   break;
13028                 case 0xf0:
13029                   goto op_semantics_114;
13030                   break;
13031               }
13032             break;
13033           case 0xe7:
13034               GETBYTE ();
13035               switch (op[2] & 0xf0)
13036               {
13037                 case 0x00:
13038                 case 0x10:
13039                 case 0x20:
13040                 case 0x30:
13041                 case 0x40:
13042                 case 0x50:
13043                 case 0x60:
13044                 case 0x70:
13045                 case 0x80:
13046                 case 0x90:
13047                 case 0xa0:
13048                 case 0xb0:
13049                 case 0xc0:
13050                 case 0xd0:
13051                 case 0xe0:
13052                   goto op_semantics_113;
13053                   break;
13054                 case 0xf0:
13055                   goto op_semantics_114;
13056                   break;
13057               }
13058             break;
13059           case 0xe8:
13060               GETBYTE ();
13061               switch (op[2] & 0xf0)
13062               {
13063                 case 0x00:
13064                 case 0x10:
13065                 case 0x20:
13066                 case 0x30:
13067                 case 0x40:
13068                 case 0x50:
13069                 case 0x60:
13070                 case 0x70:
13071                 case 0x80:
13072                 case 0x90:
13073                 case 0xa0:
13074                 case 0xb0:
13075                 case 0xc0:
13076                 case 0xd0:
13077                 case 0xe0:
13078                   goto op_semantics_113;
13079                   break;
13080                 case 0xf0:
13081                   goto op_semantics_114;
13082                   break;
13083               }
13084             break;
13085           case 0xe9:
13086               GETBYTE ();
13087               switch (op[2] & 0xf0)
13088               {
13089                 case 0x00:
13090                 case 0x10:
13091                 case 0x20:
13092                 case 0x30:
13093                 case 0x40:
13094                 case 0x50:
13095                 case 0x60:
13096                 case 0x70:
13097                 case 0x80:
13098                 case 0x90:
13099                 case 0xa0:
13100                 case 0xb0:
13101                 case 0xc0:
13102                 case 0xd0:
13103                 case 0xe0:
13104                   goto op_semantics_113;
13105                   break;
13106                 case 0xf0:
13107                   goto op_semantics_114;
13108                   break;
13109               }
13110             break;
13111           case 0xea:
13112               GETBYTE ();
13113               switch (op[2] & 0xf0)
13114               {
13115                 case 0x00:
13116                 case 0x10:
13117                 case 0x20:
13118                 case 0x30:
13119                 case 0x40:
13120                 case 0x50:
13121                 case 0x60:
13122                 case 0x70:
13123                 case 0x80:
13124                 case 0x90:
13125                 case 0xa0:
13126                 case 0xb0:
13127                 case 0xc0:
13128                 case 0xd0:
13129                 case 0xe0:
13130                   goto op_semantics_113;
13131                   break;
13132                 case 0xf0:
13133                   goto op_semantics_114;
13134                   break;
13135               }
13136             break;
13137           case 0xeb:
13138               GETBYTE ();
13139               switch (op[2] & 0xf0)
13140               {
13141                 case 0x00:
13142                 case 0x10:
13143                 case 0x20:
13144                 case 0x30:
13145                 case 0x40:
13146                 case 0x50:
13147                 case 0x60:
13148                 case 0x70:
13149                 case 0x80:
13150                 case 0x90:
13151                 case 0xa0:
13152                 case 0xb0:
13153                 case 0xc0:
13154                 case 0xd0:
13155                 case 0xe0:
13156                   goto op_semantics_113;
13157                   break;
13158                 case 0xf0:
13159                   goto op_semantics_114;
13160                   break;
13161               }
13162             break;
13163           case 0xec:
13164               GETBYTE ();
13165               switch (op[2] & 0xf0)
13166               {
13167                 case 0x00:
13168                 case 0x10:
13169                 case 0x20:
13170                 case 0x30:
13171                 case 0x40:
13172                 case 0x50:
13173                 case 0x60:
13174                 case 0x70:
13175                 case 0x80:
13176                 case 0x90:
13177                 case 0xa0:
13178                 case 0xb0:
13179                 case 0xc0:
13180                 case 0xd0:
13181                 case 0xe0:
13182                   goto op_semantics_113;
13183                   break;
13184                 case 0xf0:
13185                   goto op_semantics_114;
13186                   break;
13187               }
13188             break;
13189           case 0xed:
13190               GETBYTE ();
13191               switch (op[2] & 0xf0)
13192               {
13193                 case 0x00:
13194                 case 0x10:
13195                 case 0x20:
13196                 case 0x30:
13197                 case 0x40:
13198                 case 0x50:
13199                 case 0x60:
13200                 case 0x70:
13201                 case 0x80:
13202                 case 0x90:
13203                 case 0xa0:
13204                 case 0xb0:
13205                 case 0xc0:
13206                 case 0xd0:
13207                 case 0xe0:
13208                   goto op_semantics_113;
13209                   break;
13210                 case 0xf0:
13211                   goto op_semantics_114;
13212                   break;
13213               }
13214             break;
13215           case 0xee:
13216               GETBYTE ();
13217               switch (op[2] & 0xf0)
13218               {
13219                 case 0x00:
13220                 case 0x10:
13221                 case 0x20:
13222                 case 0x30:
13223                 case 0x40:
13224                 case 0x50:
13225                 case 0x60:
13226                 case 0x70:
13227                 case 0x80:
13228                 case 0x90:
13229                 case 0xa0:
13230                 case 0xb0:
13231                 case 0xc0:
13232                 case 0xd0:
13233                 case 0xe0:
13234                   goto op_semantics_113;
13235                   break;
13236                 case 0xf0:
13237                   goto op_semantics_114;
13238                   break;
13239               }
13240             break;
13241           case 0xef:
13242               GETBYTE ();
13243               switch (op[2] & 0xf0)
13244               {
13245                 case 0x00:
13246                 case 0x10:
13247                 case 0x20:
13248                 case 0x30:
13249                 case 0x40:
13250                 case 0x50:
13251                 case 0x60:
13252                 case 0x70:
13253                 case 0x80:
13254                 case 0x90:
13255                 case 0xa0:
13256                 case 0xb0:
13257                 case 0xc0:
13258                 case 0xd0:
13259                 case 0xe0:
13260                   goto op_semantics_113;
13261                   break;
13262                 case 0xf0:
13263                   goto op_semantics_114;
13264                   break;
13265               }
13266             break;
13267           case 0xf0:
13268               GETBYTE ();
13269               switch (op[2] & 0xf0)
13270               {
13271                 case 0x00:
13272                 case 0x10:
13273                 case 0x20:
13274                 case 0x30:
13275                 case 0x40:
13276                 case 0x50:
13277                 case 0x60:
13278                 case 0x70:
13279                 case 0x80:
13280                 case 0x90:
13281                 case 0xa0:
13282                 case 0xb0:
13283                 case 0xc0:
13284                 case 0xd0:
13285                 case 0xe0:
13286                   goto op_semantics_113;
13287                   break;
13288                 case 0xf0:
13289                   goto op_semantics_114;
13290                   break;
13291               }
13292             break;
13293           case 0xf1:
13294               GETBYTE ();
13295               switch (op[2] & 0xf0)
13296               {
13297                 case 0x00:
13298                 case 0x10:
13299                 case 0x20:
13300                 case 0x30:
13301                 case 0x40:
13302                 case 0x50:
13303                 case 0x60:
13304                 case 0x70:
13305                 case 0x80:
13306                 case 0x90:
13307                 case 0xa0:
13308                 case 0xb0:
13309                 case 0xc0:
13310                 case 0xd0:
13311                 case 0xe0:
13312                   goto op_semantics_113;
13313                   break;
13314                 case 0xf0:
13315                   goto op_semantics_114;
13316                   break;
13317               }
13318             break;
13319           case 0xf2:
13320               GETBYTE ();
13321               switch (op[2] & 0xf0)
13322               {
13323                 case 0x00:
13324                 case 0x10:
13325                 case 0x20:
13326                 case 0x30:
13327                 case 0x40:
13328                 case 0x50:
13329                 case 0x60:
13330                 case 0x70:
13331                 case 0x80:
13332                 case 0x90:
13333                 case 0xa0:
13334                 case 0xb0:
13335                 case 0xc0:
13336                 case 0xd0:
13337                 case 0xe0:
13338                   goto op_semantics_113;
13339                   break;
13340                 case 0xf0:
13341                   goto op_semantics_114;
13342                   break;
13343               }
13344             break;
13345           case 0xf3:
13346               GETBYTE ();
13347               switch (op[2] & 0xf0)
13348               {
13349                 case 0x00:
13350                 case 0x10:
13351                 case 0x20:
13352                 case 0x30:
13353                 case 0x40:
13354                 case 0x50:
13355                 case 0x60:
13356                 case 0x70:
13357                 case 0x80:
13358                 case 0x90:
13359                 case 0xa0:
13360                 case 0xb0:
13361                 case 0xc0:
13362                 case 0xd0:
13363                 case 0xe0:
13364                   goto op_semantics_113;
13365                   break;
13366                 case 0xf0:
13367                   goto op_semantics_114;
13368                   break;
13369               }
13370             break;
13371           case 0xf4:
13372               GETBYTE ();
13373               switch (op[2] & 0xf0)
13374               {
13375                 case 0x00:
13376                 case 0x10:
13377                 case 0x20:
13378                 case 0x30:
13379                 case 0x40:
13380                 case 0x50:
13381                 case 0x60:
13382                 case 0x70:
13383                 case 0x80:
13384                 case 0x90:
13385                 case 0xa0:
13386                 case 0xb0:
13387                 case 0xc0:
13388                 case 0xd0:
13389                 case 0xe0:
13390                   goto op_semantics_113;
13391                   break;
13392                 case 0xf0:
13393                   goto op_semantics_114;
13394                   break;
13395               }
13396             break;
13397           case 0xf5:
13398               GETBYTE ();
13399               switch (op[2] & 0xf0)
13400               {
13401                 case 0x00:
13402                 case 0x10:
13403                 case 0x20:
13404                 case 0x30:
13405                 case 0x40:
13406                 case 0x50:
13407                 case 0x60:
13408                 case 0x70:
13409                 case 0x80:
13410                 case 0x90:
13411                 case 0xa0:
13412                 case 0xb0:
13413                 case 0xc0:
13414                 case 0xd0:
13415                 case 0xe0:
13416                   goto op_semantics_113;
13417                   break;
13418                 case 0xf0:
13419                   goto op_semantics_114;
13420                   break;
13421               }
13422             break;
13423           case 0xf6:
13424               GETBYTE ();
13425               switch (op[2] & 0xf0)
13426               {
13427                 case 0x00:
13428                 case 0x10:
13429                 case 0x20:
13430                 case 0x30:
13431                 case 0x40:
13432                 case 0x50:
13433                 case 0x60:
13434                 case 0x70:
13435                 case 0x80:
13436                 case 0x90:
13437                 case 0xa0:
13438                 case 0xb0:
13439                 case 0xc0:
13440                 case 0xd0:
13441                 case 0xe0:
13442                   goto op_semantics_113;
13443                   break;
13444                 case 0xf0:
13445                   goto op_semantics_114;
13446                   break;
13447               }
13448             break;
13449           case 0xf7:
13450               GETBYTE ();
13451               switch (op[2] & 0xf0)
13452               {
13453                 case 0x00:
13454                 case 0x10:
13455                 case 0x20:
13456                 case 0x30:
13457                 case 0x40:
13458                 case 0x50:
13459                 case 0x60:
13460                 case 0x70:
13461                 case 0x80:
13462                 case 0x90:
13463                 case 0xa0:
13464                 case 0xb0:
13465                 case 0xc0:
13466                 case 0xd0:
13467                 case 0xe0:
13468                   goto op_semantics_113;
13469                   break;
13470                 case 0xf0:
13471                   goto op_semantics_114;
13472                   break;
13473               }
13474             break;
13475           case 0xf8:
13476               GETBYTE ();
13477               switch (op[2] & 0xf0)
13478               {
13479                 case 0x00:
13480                 case 0x10:
13481                 case 0x20:
13482                 case 0x30:
13483                 case 0x40:
13484                 case 0x50:
13485                 case 0x60:
13486                 case 0x70:
13487                 case 0x80:
13488                 case 0x90:
13489                 case 0xa0:
13490                 case 0xb0:
13491                 case 0xc0:
13492                 case 0xd0:
13493                 case 0xe0:
13494                   goto op_semantics_113;
13495                   break;
13496                 case 0xf0:
13497                   goto op_semantics_114;
13498                   break;
13499               }
13500             break;
13501           case 0xf9:
13502               GETBYTE ();
13503               switch (op[2] & 0xf0)
13504               {
13505                 case 0x00:
13506                 case 0x10:
13507                 case 0x20:
13508                 case 0x30:
13509                 case 0x40:
13510                 case 0x50:
13511                 case 0x60:
13512                 case 0x70:
13513                 case 0x80:
13514                 case 0x90:
13515                 case 0xa0:
13516                 case 0xb0:
13517                 case 0xc0:
13518                 case 0xd0:
13519                 case 0xe0:
13520                   goto op_semantics_113;
13521                   break;
13522                 case 0xf0:
13523                   goto op_semantics_114;
13524                   break;
13525               }
13526             break;
13527           case 0xfa:
13528               GETBYTE ();
13529               switch (op[2] & 0xf0)
13530               {
13531                 case 0x00:
13532                 case 0x10:
13533                 case 0x20:
13534                 case 0x30:
13535                 case 0x40:
13536                 case 0x50:
13537                 case 0x60:
13538                 case 0x70:
13539                 case 0x80:
13540                 case 0x90:
13541                 case 0xa0:
13542                 case 0xb0:
13543                 case 0xc0:
13544                 case 0xd0:
13545                 case 0xe0:
13546                   goto op_semantics_113;
13547                   break;
13548                 case 0xf0:
13549                   goto op_semantics_114;
13550                   break;
13551               }
13552             break;
13553           case 0xfb:
13554               GETBYTE ();
13555               switch (op[2] & 0xf0)
13556               {
13557                 case 0x00:
13558                 case 0x10:
13559                 case 0x20:
13560                 case 0x30:
13561                 case 0x40:
13562                 case 0x50:
13563                 case 0x60:
13564                 case 0x70:
13565                 case 0x80:
13566                 case 0x90:
13567                 case 0xa0:
13568                 case 0xb0:
13569                 case 0xc0:
13570                 case 0xd0:
13571                 case 0xe0:
13572                   goto op_semantics_113;
13573                   break;
13574                 case 0xf0:
13575                   goto op_semantics_114;
13576                   break;
13577               }
13578             break;
13579           case 0xfc:
13580               GETBYTE ();
13581               switch (op[2] & 0xf0)
13582               {
13583                 case 0x00:
13584                 case 0x10:
13585                 case 0x20:
13586                 case 0x30:
13587                 case 0x40:
13588                 case 0x50:
13589                 case 0x60:
13590                 case 0x70:
13591                 case 0x80:
13592                 case 0x90:
13593                 case 0xa0:
13594                 case 0xb0:
13595                 case 0xc0:
13596                 case 0xd0:
13597                 case 0xe0:
13598                   goto op_semantics_113;
13599                   break;
13600                 case 0xf0:
13601                   goto op_semantics_114;
13602                   break;
13603               }
13604             break;
13605           case 0xfd:
13606               GETBYTE ();
13607               switch (op[2] & 0xf0)
13608               {
13609                 case 0x00:
13610                 case 0x10:
13611                 case 0x20:
13612                 case 0x30:
13613                 case 0x40:
13614                 case 0x50:
13615                 case 0x60:
13616                 case 0x70:
13617                 case 0x80:
13618                 case 0x90:
13619                 case 0xa0:
13620                 case 0xb0:
13621                 case 0xc0:
13622                 case 0xd0:
13623                 case 0xe0:
13624                   goto op_semantics_113;
13625                   break;
13626                 case 0xf0:
13627                   goto op_semantics_114;
13628                   break;
13629               }
13630             break;
13631           case 0xfe:
13632               GETBYTE ();
13633               switch (op[2] & 0xf0)
13634               {
13635                 case 0x00:
13636                 case 0x10:
13637                 case 0x20:
13638                 case 0x30:
13639                 case 0x40:
13640                 case 0x50:
13641                 case 0x60:
13642                 case 0x70:
13643                 case 0x80:
13644                 case 0x90:
13645                 case 0xa0:
13646                 case 0xb0:
13647                 case 0xc0:
13648                 case 0xd0:
13649                 case 0xe0:
13650                   goto op_semantics_113;
13651                   break;
13652                 case 0xf0:
13653                   goto op_semantics_114;
13654                   break;
13655               }
13656             break;
13657           case 0xff:
13658               GETBYTE ();
13659               switch (op[2] & 0xf0)
13660               {
13661                 case 0x00:
13662                 case 0x10:
13663                 case 0x20:
13664                 case 0x30:
13665                 case 0x40:
13666                 case 0x50:
13667                 case 0x60:
13668                 case 0x70:
13669                 case 0x80:
13670                 case 0x90:
13671                 case 0xa0:
13672                 case 0xb0:
13673                 case 0xc0:
13674                 case 0xd0:
13675                 case 0xe0:
13676                   goto op_semantics_113;
13677                   break;
13678                 case 0xf0:
13679                   goto op_semantics_114;
13680                   break;
13681               }
13682             break;
13683           default: UNSUPPORTED(); break;
13684         }
13685       break;
13686     case 0xfe:
13687         GETBYTE ();
13688         switch (op[1] & 0xff)
13689         {
13690           case 0x00:
13691               GETBYTE ();
13692               switch (op[2] & 0x00)
13693               {
13694                 case 0x00:
13695                   op_semantics_115:
13696                     {
13697                       /** 1111 1110 00sz isrc bsrc rdst mov%s   %0, [%1, %2] */
13698 #line 342 "rx-decode.opc"
13699                       int sz AU = (op[1] >> 4) & 0x03;
13700 #line 342 "rx-decode.opc"
13701                       int isrc AU = op[1] & 0x0f;
13702 #line 342 "rx-decode.opc"
13703                       int bsrc AU = (op[2] >> 4) & 0x0f;
13704 #line 342 "rx-decode.opc"
13705                       int rdst AU = op[2] & 0x0f;
13706                       if (trace)
13707                         {
13708                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13709                                  "/** 1111 1110 00sz isrc bsrc rdst     mov%s   %0, [%1, %2] */",
13710                                  op[0], op[1], op[2]);
13711                           printf ("  sz = 0x%x,", sz);
13712                           printf ("  isrc = 0x%x,", isrc);
13713                           printf ("  bsrc = 0x%x,", bsrc);
13714                           printf ("  rdst = 0x%x\n", rdst);
13715                         }
13716                       SYNTAX("mov%s     %0, [%1, %2]");
13717 #line 342 "rx-decode.opc"
13718                       ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13719
13720                     }
13721                   break;
13722               }
13723             break;
13724           case 0x01:
13725               GETBYTE ();
13726               switch (op[2] & 0x00)
13727               {
13728                 case 0x00:
13729                   goto op_semantics_115;
13730                   break;
13731               }
13732             break;
13733           case 0x02:
13734               GETBYTE ();
13735               switch (op[2] & 0x00)
13736               {
13737                 case 0x00:
13738                   goto op_semantics_115;
13739                   break;
13740               }
13741             break;
13742           case 0x03:
13743               GETBYTE ();
13744               switch (op[2] & 0x00)
13745               {
13746                 case 0x00:
13747                   goto op_semantics_115;
13748                   break;
13749               }
13750             break;
13751           case 0x04:
13752               GETBYTE ();
13753               switch (op[2] & 0x00)
13754               {
13755                 case 0x00:
13756                   goto op_semantics_115;
13757                   break;
13758               }
13759             break;
13760           case 0x05:
13761               GETBYTE ();
13762               switch (op[2] & 0x00)
13763               {
13764                 case 0x00:
13765                   goto op_semantics_115;
13766                   break;
13767               }
13768             break;
13769           case 0x06:
13770               GETBYTE ();
13771               switch (op[2] & 0x00)
13772               {
13773                 case 0x00:
13774                   goto op_semantics_115;
13775                   break;
13776               }
13777             break;
13778           case 0x07:
13779               GETBYTE ();
13780               switch (op[2] & 0x00)
13781               {
13782                 case 0x00:
13783                   goto op_semantics_115;
13784                   break;
13785               }
13786             break;
13787           case 0x08:
13788               GETBYTE ();
13789               switch (op[2] & 0x00)
13790               {
13791                 case 0x00:
13792                   goto op_semantics_115;
13793                   break;
13794               }
13795             break;
13796           case 0x09:
13797               GETBYTE ();
13798               switch (op[2] & 0x00)
13799               {
13800                 case 0x00:
13801                   goto op_semantics_115;
13802                   break;
13803               }
13804             break;
13805           case 0x0a:
13806               GETBYTE ();
13807               switch (op[2] & 0x00)
13808               {
13809                 case 0x00:
13810                   goto op_semantics_115;
13811                   break;
13812               }
13813             break;
13814           case 0x0b:
13815               GETBYTE ();
13816               switch (op[2] & 0x00)
13817               {
13818                 case 0x00:
13819                   goto op_semantics_115;
13820                   break;
13821               }
13822             break;
13823           case 0x0c:
13824               GETBYTE ();
13825               switch (op[2] & 0x00)
13826               {
13827                 case 0x00:
13828                   goto op_semantics_115;
13829                   break;
13830               }
13831             break;
13832           case 0x0d:
13833               GETBYTE ();
13834               switch (op[2] & 0x00)
13835               {
13836                 case 0x00:
13837                   goto op_semantics_115;
13838                   break;
13839               }
13840             break;
13841           case 0x0e:
13842               GETBYTE ();
13843               switch (op[2] & 0x00)
13844               {
13845                 case 0x00:
13846                   goto op_semantics_115;
13847                   break;
13848               }
13849             break;
13850           case 0x0f:
13851               GETBYTE ();
13852               switch (op[2] & 0x00)
13853               {
13854                 case 0x00:
13855                   goto op_semantics_115;
13856                   break;
13857               }
13858             break;
13859           case 0x10:
13860               GETBYTE ();
13861               switch (op[2] & 0x00)
13862               {
13863                 case 0x00:
13864                   goto op_semantics_115;
13865                   break;
13866               }
13867             break;
13868           case 0x11:
13869               GETBYTE ();
13870               switch (op[2] & 0x00)
13871               {
13872                 case 0x00:
13873                   goto op_semantics_115;
13874                   break;
13875               }
13876             break;
13877           case 0x12:
13878               GETBYTE ();
13879               switch (op[2] & 0x00)
13880               {
13881                 case 0x00:
13882                   goto op_semantics_115;
13883                   break;
13884               }
13885             break;
13886           case 0x13:
13887               GETBYTE ();
13888               switch (op[2] & 0x00)
13889               {
13890                 case 0x00:
13891                   goto op_semantics_115;
13892                   break;
13893               }
13894             break;
13895           case 0x14:
13896               GETBYTE ();
13897               switch (op[2] & 0x00)
13898               {
13899                 case 0x00:
13900                   goto op_semantics_115;
13901                   break;
13902               }
13903             break;
13904           case 0x15:
13905               GETBYTE ();
13906               switch (op[2] & 0x00)
13907               {
13908                 case 0x00:
13909                   goto op_semantics_115;
13910                   break;
13911               }
13912             break;
13913           case 0x16:
13914               GETBYTE ();
13915               switch (op[2] & 0x00)
13916               {
13917                 case 0x00:
13918                   goto op_semantics_115;
13919                   break;
13920               }
13921             break;
13922           case 0x17:
13923               GETBYTE ();
13924               switch (op[2] & 0x00)
13925               {
13926                 case 0x00:
13927                   goto op_semantics_115;
13928                   break;
13929               }
13930             break;
13931           case 0x18:
13932               GETBYTE ();
13933               switch (op[2] & 0x00)
13934               {
13935                 case 0x00:
13936                   goto op_semantics_115;
13937                   break;
13938               }
13939             break;
13940           case 0x19:
13941               GETBYTE ();
13942               switch (op[2] & 0x00)
13943               {
13944                 case 0x00:
13945                   goto op_semantics_115;
13946                   break;
13947               }
13948             break;
13949           case 0x1a:
13950               GETBYTE ();
13951               switch (op[2] & 0x00)
13952               {
13953                 case 0x00:
13954                   goto op_semantics_115;
13955                   break;
13956               }
13957             break;
13958           case 0x1b:
13959               GETBYTE ();
13960               switch (op[2] & 0x00)
13961               {
13962                 case 0x00:
13963                   goto op_semantics_115;
13964                   break;
13965               }
13966             break;
13967           case 0x1c:
13968               GETBYTE ();
13969               switch (op[2] & 0x00)
13970               {
13971                 case 0x00:
13972                   goto op_semantics_115;
13973                   break;
13974               }
13975             break;
13976           case 0x1d:
13977               GETBYTE ();
13978               switch (op[2] & 0x00)
13979               {
13980                 case 0x00:
13981                   goto op_semantics_115;
13982                   break;
13983               }
13984             break;
13985           case 0x1e:
13986               GETBYTE ();
13987               switch (op[2] & 0x00)
13988               {
13989                 case 0x00:
13990                   goto op_semantics_115;
13991                   break;
13992               }
13993             break;
13994           case 0x1f:
13995               GETBYTE ();
13996               switch (op[2] & 0x00)
13997               {
13998                 case 0x00:
13999                   goto op_semantics_115;
14000                   break;
14001               }
14002             break;
14003           case 0x20:
14004               GETBYTE ();
14005               switch (op[2] & 0x00)
14006               {
14007                 case 0x00:
14008                   goto op_semantics_115;
14009                   break;
14010               }
14011             break;
14012           case 0x21:
14013               GETBYTE ();
14014               switch (op[2] & 0x00)
14015               {
14016                 case 0x00:
14017                   goto op_semantics_115;
14018                   break;
14019               }
14020             break;
14021           case 0x22:
14022               GETBYTE ();
14023               switch (op[2] & 0x00)
14024               {
14025                 case 0x00:
14026                   goto op_semantics_115;
14027                   break;
14028               }
14029             break;
14030           case 0x23:
14031               GETBYTE ();
14032               switch (op[2] & 0x00)
14033               {
14034                 case 0x00:
14035                   goto op_semantics_115;
14036                   break;
14037               }
14038             break;
14039           case 0x24:
14040               GETBYTE ();
14041               switch (op[2] & 0x00)
14042               {
14043                 case 0x00:
14044                   goto op_semantics_115;
14045                   break;
14046               }
14047             break;
14048           case 0x25:
14049               GETBYTE ();
14050               switch (op[2] & 0x00)
14051               {
14052                 case 0x00:
14053                   goto op_semantics_115;
14054                   break;
14055               }
14056             break;
14057           case 0x26:
14058               GETBYTE ();
14059               switch (op[2] & 0x00)
14060               {
14061                 case 0x00:
14062                   goto op_semantics_115;
14063                   break;
14064               }
14065             break;
14066           case 0x27:
14067               GETBYTE ();
14068               switch (op[2] & 0x00)
14069               {
14070                 case 0x00:
14071                   goto op_semantics_115;
14072                   break;
14073               }
14074             break;
14075           case 0x28:
14076               GETBYTE ();
14077               switch (op[2] & 0x00)
14078               {
14079                 case 0x00:
14080                   goto op_semantics_115;
14081                   break;
14082               }
14083             break;
14084           case 0x29:
14085               GETBYTE ();
14086               switch (op[2] & 0x00)
14087               {
14088                 case 0x00:
14089                   goto op_semantics_115;
14090                   break;
14091               }
14092             break;
14093           case 0x2a:
14094               GETBYTE ();
14095               switch (op[2] & 0x00)
14096               {
14097                 case 0x00:
14098                   goto op_semantics_115;
14099                   break;
14100               }
14101             break;
14102           case 0x2b:
14103               GETBYTE ();
14104               switch (op[2] & 0x00)
14105               {
14106                 case 0x00:
14107                   goto op_semantics_115;
14108                   break;
14109               }
14110             break;
14111           case 0x2c:
14112               GETBYTE ();
14113               switch (op[2] & 0x00)
14114               {
14115                 case 0x00:
14116                   goto op_semantics_115;
14117                   break;
14118               }
14119             break;
14120           case 0x2d:
14121               GETBYTE ();
14122               switch (op[2] & 0x00)
14123               {
14124                 case 0x00:
14125                   goto op_semantics_115;
14126                   break;
14127               }
14128             break;
14129           case 0x2e:
14130               GETBYTE ();
14131               switch (op[2] & 0x00)
14132               {
14133                 case 0x00:
14134                   goto op_semantics_115;
14135                   break;
14136               }
14137             break;
14138           case 0x2f:
14139               GETBYTE ();
14140               switch (op[2] & 0x00)
14141               {
14142                 case 0x00:
14143                   goto op_semantics_115;
14144                   break;
14145               }
14146             break;
14147           case 0x40:
14148               GETBYTE ();
14149               switch (op[2] & 0x00)
14150               {
14151                 case 0x00:
14152                   op_semantics_116:
14153                     {
14154                       /** 1111 1110 01sz isrc bsrc rdst mov%s   [%1, %2], %0 */
14155 #line 339 "rx-decode.opc"
14156                       int sz AU = (op[1] >> 4) & 0x03;
14157 #line 339 "rx-decode.opc"
14158                       int isrc AU = op[1] & 0x0f;
14159 #line 339 "rx-decode.opc"
14160                       int bsrc AU = (op[2] >> 4) & 0x0f;
14161 #line 339 "rx-decode.opc"
14162                       int rdst AU = op[2] & 0x0f;
14163                       if (trace)
14164                         {
14165                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14166                                  "/** 1111 1110 01sz isrc bsrc rdst     mov%s   [%1, %2], %0 */",
14167                                  op[0], op[1], op[2]);
14168                           printf ("  sz = 0x%x,", sz);
14169                           printf ("  isrc = 0x%x,", isrc);
14170                           printf ("  bsrc = 0x%x,", bsrc);
14171                           printf ("  rdst = 0x%x\n", rdst);
14172                         }
14173                       SYNTAX("mov%s     [%1, %2], %0");
14174 #line 339 "rx-decode.opc"
14175                       ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
14176
14177                     }
14178                   break;
14179               }
14180             break;
14181           case 0x41:
14182               GETBYTE ();
14183               switch (op[2] & 0x00)
14184               {
14185                 case 0x00:
14186                   goto op_semantics_116;
14187                   break;
14188               }
14189             break;
14190           case 0x42:
14191               GETBYTE ();
14192               switch (op[2] & 0x00)
14193               {
14194                 case 0x00:
14195                   goto op_semantics_116;
14196                   break;
14197               }
14198             break;
14199           case 0x43:
14200               GETBYTE ();
14201               switch (op[2] & 0x00)
14202               {
14203                 case 0x00:
14204                   goto op_semantics_116;
14205                   break;
14206               }
14207             break;
14208           case 0x44:
14209               GETBYTE ();
14210               switch (op[2] & 0x00)
14211               {
14212                 case 0x00:
14213                   goto op_semantics_116;
14214                   break;
14215               }
14216             break;
14217           case 0x45:
14218               GETBYTE ();
14219               switch (op[2] & 0x00)
14220               {
14221                 case 0x00:
14222                   goto op_semantics_116;
14223                   break;
14224               }
14225             break;
14226           case 0x46:
14227               GETBYTE ();
14228               switch (op[2] & 0x00)
14229               {
14230                 case 0x00:
14231                   goto op_semantics_116;
14232                   break;
14233               }
14234             break;
14235           case 0x47:
14236               GETBYTE ();
14237               switch (op[2] & 0x00)
14238               {
14239                 case 0x00:
14240                   goto op_semantics_116;
14241                   break;
14242               }
14243             break;
14244           case 0x48:
14245               GETBYTE ();
14246               switch (op[2] & 0x00)
14247               {
14248                 case 0x00:
14249                   goto op_semantics_116;
14250                   break;
14251               }
14252             break;
14253           case 0x49:
14254               GETBYTE ();
14255               switch (op[2] & 0x00)
14256               {
14257                 case 0x00:
14258                   goto op_semantics_116;
14259                   break;
14260               }
14261             break;
14262           case 0x4a:
14263               GETBYTE ();
14264               switch (op[2] & 0x00)
14265               {
14266                 case 0x00:
14267                   goto op_semantics_116;
14268                   break;
14269               }
14270             break;
14271           case 0x4b:
14272               GETBYTE ();
14273               switch (op[2] & 0x00)
14274               {
14275                 case 0x00:
14276                   goto op_semantics_116;
14277                   break;
14278               }
14279             break;
14280           case 0x4c:
14281               GETBYTE ();
14282               switch (op[2] & 0x00)
14283               {
14284                 case 0x00:
14285                   goto op_semantics_116;
14286                   break;
14287               }
14288             break;
14289           case 0x4d:
14290               GETBYTE ();
14291               switch (op[2] & 0x00)
14292               {
14293                 case 0x00:
14294                   goto op_semantics_116;
14295                   break;
14296               }
14297             break;
14298           case 0x4e:
14299               GETBYTE ();
14300               switch (op[2] & 0x00)
14301               {
14302                 case 0x00:
14303                   goto op_semantics_116;
14304                   break;
14305               }
14306             break;
14307           case 0x4f:
14308               GETBYTE ();
14309               switch (op[2] & 0x00)
14310               {
14311                 case 0x00:
14312                   goto op_semantics_116;
14313                   break;
14314               }
14315             break;
14316           case 0x50:
14317               GETBYTE ();
14318               switch (op[2] & 0x00)
14319               {
14320                 case 0x00:
14321                   goto op_semantics_116;
14322                   break;
14323               }
14324             break;
14325           case 0x51:
14326               GETBYTE ();
14327               switch (op[2] & 0x00)
14328               {
14329                 case 0x00:
14330                   goto op_semantics_116;
14331                   break;
14332               }
14333             break;
14334           case 0x52:
14335               GETBYTE ();
14336               switch (op[2] & 0x00)
14337               {
14338                 case 0x00:
14339                   goto op_semantics_116;
14340                   break;
14341               }
14342             break;
14343           case 0x53:
14344               GETBYTE ();
14345               switch (op[2] & 0x00)
14346               {
14347                 case 0x00:
14348                   goto op_semantics_116;
14349                   break;
14350               }
14351             break;
14352           case 0x54:
14353               GETBYTE ();
14354               switch (op[2] & 0x00)
14355               {
14356                 case 0x00:
14357                   goto op_semantics_116;
14358                   break;
14359               }
14360             break;
14361           case 0x55:
14362               GETBYTE ();
14363               switch (op[2] & 0x00)
14364               {
14365                 case 0x00:
14366                   goto op_semantics_116;
14367                   break;
14368               }
14369             break;
14370           case 0x56:
14371               GETBYTE ();
14372               switch (op[2] & 0x00)
14373               {
14374                 case 0x00:
14375                   goto op_semantics_116;
14376                   break;
14377               }
14378             break;
14379           case 0x57:
14380               GETBYTE ();
14381               switch (op[2] & 0x00)
14382               {
14383                 case 0x00:
14384                   goto op_semantics_116;
14385                   break;
14386               }
14387             break;
14388           case 0x58:
14389               GETBYTE ();
14390               switch (op[2] & 0x00)
14391               {
14392                 case 0x00:
14393                   goto op_semantics_116;
14394                   break;
14395               }
14396             break;
14397           case 0x59:
14398               GETBYTE ();
14399               switch (op[2] & 0x00)
14400               {
14401                 case 0x00:
14402                   goto op_semantics_116;
14403                   break;
14404               }
14405             break;
14406           case 0x5a:
14407               GETBYTE ();
14408               switch (op[2] & 0x00)
14409               {
14410                 case 0x00:
14411                   goto op_semantics_116;
14412                   break;
14413               }
14414             break;
14415           case 0x5b:
14416               GETBYTE ();
14417               switch (op[2] & 0x00)
14418               {
14419                 case 0x00:
14420                   goto op_semantics_116;
14421                   break;
14422               }
14423             break;
14424           case 0x5c:
14425               GETBYTE ();
14426               switch (op[2] & 0x00)
14427               {
14428                 case 0x00:
14429                   goto op_semantics_116;
14430                   break;
14431               }
14432             break;
14433           case 0x5d:
14434               GETBYTE ();
14435               switch (op[2] & 0x00)
14436               {
14437                 case 0x00:
14438                   goto op_semantics_116;
14439                   break;
14440               }
14441             break;
14442           case 0x5e:
14443               GETBYTE ();
14444               switch (op[2] & 0x00)
14445               {
14446                 case 0x00:
14447                   goto op_semantics_116;
14448                   break;
14449               }
14450             break;
14451           case 0x5f:
14452               GETBYTE ();
14453               switch (op[2] & 0x00)
14454               {
14455                 case 0x00:
14456                   goto op_semantics_116;
14457                   break;
14458               }
14459             break;
14460           case 0x60:
14461               GETBYTE ();
14462               switch (op[2] & 0x00)
14463               {
14464                 case 0x00:
14465                   goto op_semantics_116;
14466                   break;
14467               }
14468             break;
14469           case 0x61:
14470               GETBYTE ();
14471               switch (op[2] & 0x00)
14472               {
14473                 case 0x00:
14474                   goto op_semantics_116;
14475                   break;
14476               }
14477             break;
14478           case 0x62:
14479               GETBYTE ();
14480               switch (op[2] & 0x00)
14481               {
14482                 case 0x00:
14483                   goto op_semantics_116;
14484                   break;
14485               }
14486             break;
14487           case 0x63:
14488               GETBYTE ();
14489               switch (op[2] & 0x00)
14490               {
14491                 case 0x00:
14492                   goto op_semantics_116;
14493                   break;
14494               }
14495             break;
14496           case 0x64:
14497               GETBYTE ();
14498               switch (op[2] & 0x00)
14499               {
14500                 case 0x00:
14501                   goto op_semantics_116;
14502                   break;
14503               }
14504             break;
14505           case 0x65:
14506               GETBYTE ();
14507               switch (op[2] & 0x00)
14508               {
14509                 case 0x00:
14510                   goto op_semantics_116;
14511                   break;
14512               }
14513             break;
14514           case 0x66:
14515               GETBYTE ();
14516               switch (op[2] & 0x00)
14517               {
14518                 case 0x00:
14519                   goto op_semantics_116;
14520                   break;
14521               }
14522             break;
14523           case 0x67:
14524               GETBYTE ();
14525               switch (op[2] & 0x00)
14526               {
14527                 case 0x00:
14528                   goto op_semantics_116;
14529                   break;
14530               }
14531             break;
14532           case 0x68:
14533               GETBYTE ();
14534               switch (op[2] & 0x00)
14535               {
14536                 case 0x00:
14537                   goto op_semantics_116;
14538                   break;
14539               }
14540             break;
14541           case 0x69:
14542               GETBYTE ();
14543               switch (op[2] & 0x00)
14544               {
14545                 case 0x00:
14546                   goto op_semantics_116;
14547                   break;
14548               }
14549             break;
14550           case 0x6a:
14551               GETBYTE ();
14552               switch (op[2] & 0x00)
14553               {
14554                 case 0x00:
14555                   goto op_semantics_116;
14556                   break;
14557               }
14558             break;
14559           case 0x6b:
14560               GETBYTE ();
14561               switch (op[2] & 0x00)
14562               {
14563                 case 0x00:
14564                   goto op_semantics_116;
14565                   break;
14566               }
14567             break;
14568           case 0x6c:
14569               GETBYTE ();
14570               switch (op[2] & 0x00)
14571               {
14572                 case 0x00:
14573                   goto op_semantics_116;
14574                   break;
14575               }
14576             break;
14577           case 0x6d:
14578               GETBYTE ();
14579               switch (op[2] & 0x00)
14580               {
14581                 case 0x00:
14582                   goto op_semantics_116;
14583                   break;
14584               }
14585             break;
14586           case 0x6e:
14587               GETBYTE ();
14588               switch (op[2] & 0x00)
14589               {
14590                 case 0x00:
14591                   goto op_semantics_116;
14592                   break;
14593               }
14594             break;
14595           case 0x6f:
14596               GETBYTE ();
14597               switch (op[2] & 0x00)
14598               {
14599                 case 0x00:
14600                   goto op_semantics_116;
14601                   break;
14602               }
14603             break;
14604           case 0xc0:
14605               GETBYTE ();
14606               switch (op[2] & 0x00)
14607               {
14608                 case 0x00:
14609                   op_semantics_117:
14610                     {
14611                       /** 1111 1110 11sz isrc bsrc rdst movu%s  [%1, %2], %0 */
14612 #line 345 "rx-decode.opc"
14613                       int sz AU = (op[1] >> 4) & 0x03;
14614 #line 345 "rx-decode.opc"
14615                       int isrc AU = op[1] & 0x0f;
14616 #line 345 "rx-decode.opc"
14617                       int bsrc AU = (op[2] >> 4) & 0x0f;
14618 #line 345 "rx-decode.opc"
14619                       int rdst AU = op[2] & 0x0f;
14620                       if (trace)
14621                         {
14622                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14623                                  "/** 1111 1110 11sz isrc bsrc rdst     movu%s  [%1, %2], %0 */",
14624                                  op[0], op[1], op[2]);
14625                           printf ("  sz = 0x%x,", sz);
14626                           printf ("  isrc = 0x%x,", isrc);
14627                           printf ("  bsrc = 0x%x,", bsrc);
14628                           printf ("  rdst = 0x%x\n", rdst);
14629                         }
14630                       SYNTAX("movu%s    [%1, %2], %0");
14631 #line 345 "rx-decode.opc"
14632                       ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
14633
14634                     }
14635                   break;
14636               }
14637             break;
14638           case 0xc1:
14639               GETBYTE ();
14640               switch (op[2] & 0x00)
14641               {
14642                 case 0x00:
14643                   goto op_semantics_117;
14644                   break;
14645               }
14646             break;
14647           case 0xc2:
14648               GETBYTE ();
14649               switch (op[2] & 0x00)
14650               {
14651                 case 0x00:
14652                   goto op_semantics_117;
14653                   break;
14654               }
14655             break;
14656           case 0xc3:
14657               GETBYTE ();
14658               switch (op[2] & 0x00)
14659               {
14660                 case 0x00:
14661                   goto op_semantics_117;
14662                   break;
14663               }
14664             break;
14665           case 0xc4:
14666               GETBYTE ();
14667               switch (op[2] & 0x00)
14668               {
14669                 case 0x00:
14670                   goto op_semantics_117;
14671                   break;
14672               }
14673             break;
14674           case 0xc5:
14675               GETBYTE ();
14676               switch (op[2] & 0x00)
14677               {
14678                 case 0x00:
14679                   goto op_semantics_117;
14680                   break;
14681               }
14682             break;
14683           case 0xc6:
14684               GETBYTE ();
14685               switch (op[2] & 0x00)
14686               {
14687                 case 0x00:
14688                   goto op_semantics_117;
14689                   break;
14690               }
14691             break;
14692           case 0xc7:
14693               GETBYTE ();
14694               switch (op[2] & 0x00)
14695               {
14696                 case 0x00:
14697                   goto op_semantics_117;
14698                   break;
14699               }
14700             break;
14701           case 0xc8:
14702               GETBYTE ();
14703               switch (op[2] & 0x00)
14704               {
14705                 case 0x00:
14706                   goto op_semantics_117;
14707                   break;
14708               }
14709             break;
14710           case 0xc9:
14711               GETBYTE ();
14712               switch (op[2] & 0x00)
14713               {
14714                 case 0x00:
14715                   goto op_semantics_117;
14716                   break;
14717               }
14718             break;
14719           case 0xca:
14720               GETBYTE ();
14721               switch (op[2] & 0x00)
14722               {
14723                 case 0x00:
14724                   goto op_semantics_117;
14725                   break;
14726               }
14727             break;
14728           case 0xcb:
14729               GETBYTE ();
14730               switch (op[2] & 0x00)
14731               {
14732                 case 0x00:
14733                   goto op_semantics_117;
14734                   break;
14735               }
14736             break;
14737           case 0xcc:
14738               GETBYTE ();
14739               switch (op[2] & 0x00)
14740               {
14741                 case 0x00:
14742                   goto op_semantics_117;
14743                   break;
14744               }
14745             break;
14746           case 0xcd:
14747               GETBYTE ();
14748               switch (op[2] & 0x00)
14749               {
14750                 case 0x00:
14751                   goto op_semantics_117;
14752                   break;
14753               }
14754             break;
14755           case 0xce:
14756               GETBYTE ();
14757               switch (op[2] & 0x00)
14758               {
14759                 case 0x00:
14760                   goto op_semantics_117;
14761                   break;
14762               }
14763             break;
14764           case 0xcf:
14765               GETBYTE ();
14766               switch (op[2] & 0x00)
14767               {
14768                 case 0x00:
14769                   goto op_semantics_117;
14770                   break;
14771               }
14772             break;
14773           case 0xd0:
14774               GETBYTE ();
14775               switch (op[2] & 0x00)
14776               {
14777                 case 0x00:
14778                   goto op_semantics_117;
14779                   break;
14780               }
14781             break;
14782           case 0xd1:
14783               GETBYTE ();
14784               switch (op[2] & 0x00)
14785               {
14786                 case 0x00:
14787                   goto op_semantics_117;
14788                   break;
14789               }
14790             break;
14791           case 0xd2:
14792               GETBYTE ();
14793               switch (op[2] & 0x00)
14794               {
14795                 case 0x00:
14796                   goto op_semantics_117;
14797                   break;
14798               }
14799             break;
14800           case 0xd3:
14801               GETBYTE ();
14802               switch (op[2] & 0x00)
14803               {
14804                 case 0x00:
14805                   goto op_semantics_117;
14806                   break;
14807               }
14808             break;
14809           case 0xd4:
14810               GETBYTE ();
14811               switch (op[2] & 0x00)
14812               {
14813                 case 0x00:
14814                   goto op_semantics_117;
14815                   break;
14816               }
14817             break;
14818           case 0xd5:
14819               GETBYTE ();
14820               switch (op[2] & 0x00)
14821               {
14822                 case 0x00:
14823                   goto op_semantics_117;
14824                   break;
14825               }
14826             break;
14827           case 0xd6:
14828               GETBYTE ();
14829               switch (op[2] & 0x00)
14830               {
14831                 case 0x00:
14832                   goto op_semantics_117;
14833                   break;
14834               }
14835             break;
14836           case 0xd7:
14837               GETBYTE ();
14838               switch (op[2] & 0x00)
14839               {
14840                 case 0x00:
14841                   goto op_semantics_117;
14842                   break;
14843               }
14844             break;
14845           case 0xd8:
14846               GETBYTE ();
14847               switch (op[2] & 0x00)
14848               {
14849                 case 0x00:
14850                   goto op_semantics_117;
14851                   break;
14852               }
14853             break;
14854           case 0xd9:
14855               GETBYTE ();
14856               switch (op[2] & 0x00)
14857               {
14858                 case 0x00:
14859                   goto op_semantics_117;
14860                   break;
14861               }
14862             break;
14863           case 0xda:
14864               GETBYTE ();
14865               switch (op[2] & 0x00)
14866               {
14867                 case 0x00:
14868                   goto op_semantics_117;
14869                   break;
14870               }
14871             break;
14872           case 0xdb:
14873               GETBYTE ();
14874               switch (op[2] & 0x00)
14875               {
14876                 case 0x00:
14877                   goto op_semantics_117;
14878                   break;
14879               }
14880             break;
14881           case 0xdc:
14882               GETBYTE ();
14883               switch (op[2] & 0x00)
14884               {
14885                 case 0x00:
14886                   goto op_semantics_117;
14887                   break;
14888               }
14889             break;
14890           case 0xdd:
14891               GETBYTE ();
14892               switch (op[2] & 0x00)
14893               {
14894                 case 0x00:
14895                   goto op_semantics_117;
14896                   break;
14897               }
14898             break;
14899           case 0xde:
14900               GETBYTE ();
14901               switch (op[2] & 0x00)
14902               {
14903                 case 0x00:
14904                   goto op_semantics_117;
14905                   break;
14906               }
14907             break;
14908           case 0xdf:
14909               GETBYTE ();
14910               switch (op[2] & 0x00)
14911               {
14912                 case 0x00:
14913                   goto op_semantics_117;
14914                   break;
14915               }
14916             break;
14917           case 0xe0:
14918               GETBYTE ();
14919               switch (op[2] & 0x00)
14920               {
14921                 case 0x00:
14922                   goto op_semantics_117;
14923                   break;
14924               }
14925             break;
14926           case 0xe1:
14927               GETBYTE ();
14928               switch (op[2] & 0x00)
14929               {
14930                 case 0x00:
14931                   goto op_semantics_117;
14932                   break;
14933               }
14934             break;
14935           case 0xe2:
14936               GETBYTE ();
14937               switch (op[2] & 0x00)
14938               {
14939                 case 0x00:
14940                   goto op_semantics_117;
14941                   break;
14942               }
14943             break;
14944           case 0xe3:
14945               GETBYTE ();
14946               switch (op[2] & 0x00)
14947               {
14948                 case 0x00:
14949                   goto op_semantics_117;
14950                   break;
14951               }
14952             break;
14953           case 0xe4:
14954               GETBYTE ();
14955               switch (op[2] & 0x00)
14956               {
14957                 case 0x00:
14958                   goto op_semantics_117;
14959                   break;
14960               }
14961             break;
14962           case 0xe5:
14963               GETBYTE ();
14964               switch (op[2] & 0x00)
14965               {
14966                 case 0x00:
14967                   goto op_semantics_117;
14968                   break;
14969               }
14970             break;
14971           case 0xe6:
14972               GETBYTE ();
14973               switch (op[2] & 0x00)
14974               {
14975                 case 0x00:
14976                   goto op_semantics_117;
14977                   break;
14978               }
14979             break;
14980           case 0xe7:
14981               GETBYTE ();
14982               switch (op[2] & 0x00)
14983               {
14984                 case 0x00:
14985                   goto op_semantics_117;
14986                   break;
14987               }
14988             break;
14989           case 0xe8:
14990               GETBYTE ();
14991               switch (op[2] & 0x00)
14992               {
14993                 case 0x00:
14994                   goto op_semantics_117;
14995                   break;
14996               }
14997             break;
14998           case 0xe9:
14999               GETBYTE ();
15000               switch (op[2] & 0x00)
15001               {
15002                 case 0x00:
15003                   goto op_semantics_117;
15004                   break;
15005               }
15006             break;
15007           case 0xea:
15008               GETBYTE ();
15009               switch (op[2] & 0x00)
15010               {
15011                 case 0x00:
15012                   goto op_semantics_117;
15013                   break;
15014               }
15015             break;
15016           case 0xeb:
15017               GETBYTE ();
15018               switch (op[2] & 0x00)
15019               {
15020                 case 0x00:
15021                   goto op_semantics_117;
15022                   break;
15023               }
15024             break;
15025           case 0xec:
15026               GETBYTE ();
15027               switch (op[2] & 0x00)
15028               {
15029                 case 0x00:
15030                   goto op_semantics_117;
15031                   break;
15032               }
15033             break;
15034           case 0xed:
15035               GETBYTE ();
15036               switch (op[2] & 0x00)
15037               {
15038                 case 0x00:
15039                   goto op_semantics_117;
15040                   break;
15041               }
15042             break;
15043           case 0xee:
15044               GETBYTE ();
15045               switch (op[2] & 0x00)
15046               {
15047                 case 0x00:
15048                   goto op_semantics_117;
15049                   break;
15050               }
15051             break;
15052           case 0xef:
15053               GETBYTE ();
15054               switch (op[2] & 0x00)
15055               {
15056                 case 0x00:
15057                   goto op_semantics_117;
15058                   break;
15059               }
15060             break;
15061           default: UNSUPPORTED(); break;
15062         }
15063       break;
15064     case 0xff:
15065         GETBYTE ();
15066         switch (op[1] & 0xff)
15067         {
15068           case 0x00:
15069               GETBYTE ();
15070               switch (op[2] & 0x00)
15071               {
15072                 case 0x00:
15073                   op_semantics_118:
15074                     {
15075                       /** 1111 1111 0000 rdst srca srcb sub     %2, %1, %0 */
15076 #line 549 "rx-decode.opc"
15077                       int rdst AU = op[1] & 0x0f;
15078 #line 549 "rx-decode.opc"
15079                       int srca AU = (op[2] >> 4) & 0x0f;
15080 #line 549 "rx-decode.opc"
15081                       int srcb AU = op[2] & 0x0f;
15082                       if (trace)
15083                         {
15084                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15085                                  "/** 1111 1111 0000 rdst srca srcb     sub     %2, %1, %0 */",
15086                                  op[0], op[1], op[2]);
15087                           printf ("  rdst = 0x%x,", rdst);
15088                           printf ("  srca = 0x%x,", srca);
15089                           printf ("  srcb = 0x%x\n", srcb);
15090                         }
15091                       SYNTAX("sub       %2, %1, %0");
15092 #line 549 "rx-decode.opc"
15093                       ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15094
15095                     /*----------------------------------------------------------------------*/
15096                     /* SBB                                                                      */
15097
15098                     }
15099                   break;
15100               }
15101             break;
15102           case 0x01:
15103               GETBYTE ();
15104               switch (op[2] & 0x00)
15105               {
15106                 case 0x00:
15107                   goto op_semantics_118;
15108                   break;
15109               }
15110             break;
15111           case 0x02:
15112               GETBYTE ();
15113               switch (op[2] & 0x00)
15114               {
15115                 case 0x00:
15116                   goto op_semantics_118;
15117                   break;
15118               }
15119             break;
15120           case 0x03:
15121               GETBYTE ();
15122               switch (op[2] & 0x00)
15123               {
15124                 case 0x00:
15125                   goto op_semantics_118;
15126                   break;
15127               }
15128             break;
15129           case 0x04:
15130               GETBYTE ();
15131               switch (op[2] & 0x00)
15132               {
15133                 case 0x00:
15134                   goto op_semantics_118;
15135                   break;
15136               }
15137             break;
15138           case 0x05:
15139               GETBYTE ();
15140               switch (op[2] & 0x00)
15141               {
15142                 case 0x00:
15143                   goto op_semantics_118;
15144                   break;
15145               }
15146             break;
15147           case 0x06:
15148               GETBYTE ();
15149               switch (op[2] & 0x00)
15150               {
15151                 case 0x00:
15152                   goto op_semantics_118;
15153                   break;
15154               }
15155             break;
15156           case 0x07:
15157               GETBYTE ();
15158               switch (op[2] & 0x00)
15159               {
15160                 case 0x00:
15161                   goto op_semantics_118;
15162                   break;
15163               }
15164             break;
15165           case 0x08:
15166               GETBYTE ();
15167               switch (op[2] & 0x00)
15168               {
15169                 case 0x00:
15170                   goto op_semantics_118;
15171                   break;
15172               }
15173             break;
15174           case 0x09:
15175               GETBYTE ();
15176               switch (op[2] & 0x00)
15177               {
15178                 case 0x00:
15179                   goto op_semantics_118;
15180                   break;
15181               }
15182             break;
15183           case 0x0a:
15184               GETBYTE ();
15185               switch (op[2] & 0x00)
15186               {
15187                 case 0x00:
15188                   goto op_semantics_118;
15189                   break;
15190               }
15191             break;
15192           case 0x0b:
15193               GETBYTE ();
15194               switch (op[2] & 0x00)
15195               {
15196                 case 0x00:
15197                   goto op_semantics_118;
15198                   break;
15199               }
15200             break;
15201           case 0x0c:
15202               GETBYTE ();
15203               switch (op[2] & 0x00)
15204               {
15205                 case 0x00:
15206                   goto op_semantics_118;
15207                   break;
15208               }
15209             break;
15210           case 0x0d:
15211               GETBYTE ();
15212               switch (op[2] & 0x00)
15213               {
15214                 case 0x00:
15215                   goto op_semantics_118;
15216                   break;
15217               }
15218             break;
15219           case 0x0e:
15220               GETBYTE ();
15221               switch (op[2] & 0x00)
15222               {
15223                 case 0x00:
15224                   goto op_semantics_118;
15225                   break;
15226               }
15227             break;
15228           case 0x0f:
15229               GETBYTE ();
15230               switch (op[2] & 0x00)
15231               {
15232                 case 0x00:
15233                   goto op_semantics_118;
15234                   break;
15235               }
15236             break;
15237           case 0x20:
15238               GETBYTE ();
15239               switch (op[2] & 0x00)
15240               {
15241                 case 0x00:
15242                   op_semantics_119:
15243                     {
15244                       /** 1111 1111 0010 rdst srca srcb add     %2, %1, %0 */
15245 #line 516 "rx-decode.opc"
15246                       int rdst AU = op[1] & 0x0f;
15247 #line 516 "rx-decode.opc"
15248                       int srca AU = (op[2] >> 4) & 0x0f;
15249 #line 516 "rx-decode.opc"
15250                       int srcb AU = op[2] & 0x0f;
15251                       if (trace)
15252                         {
15253                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15254                                  "/** 1111 1111 0010 rdst srca srcb     add     %2, %1, %0 */",
15255                                  op[0], op[1], op[2]);
15256                           printf ("  rdst = 0x%x,", rdst);
15257                           printf ("  srca = 0x%x,", srca);
15258                           printf ("  srcb = 0x%x\n", srcb);
15259                         }
15260                       SYNTAX("add       %2, %1, %0");
15261 #line 516 "rx-decode.opc"
15262                       ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15263
15264                     /*----------------------------------------------------------------------*/
15265                     /* CMP                                                                      */
15266
15267                     }
15268                   break;
15269               }
15270             break;
15271           case 0x21:
15272               GETBYTE ();
15273               switch (op[2] & 0x00)
15274               {
15275                 case 0x00:
15276                   goto op_semantics_119;
15277                   break;
15278               }
15279             break;
15280           case 0x22:
15281               GETBYTE ();
15282               switch (op[2] & 0x00)
15283               {
15284                 case 0x00:
15285                   goto op_semantics_119;
15286                   break;
15287               }
15288             break;
15289           case 0x23:
15290               GETBYTE ();
15291               switch (op[2] & 0x00)
15292               {
15293                 case 0x00:
15294                   goto op_semantics_119;
15295                   break;
15296               }
15297             break;
15298           case 0x24:
15299               GETBYTE ();
15300               switch (op[2] & 0x00)
15301               {
15302                 case 0x00:
15303                   goto op_semantics_119;
15304                   break;
15305               }
15306             break;
15307           case 0x25:
15308               GETBYTE ();
15309               switch (op[2] & 0x00)
15310               {
15311                 case 0x00:
15312                   goto op_semantics_119;
15313                   break;
15314               }
15315             break;
15316           case 0x26:
15317               GETBYTE ();
15318               switch (op[2] & 0x00)
15319               {
15320                 case 0x00:
15321                   goto op_semantics_119;
15322                   break;
15323               }
15324             break;
15325           case 0x27:
15326               GETBYTE ();
15327               switch (op[2] & 0x00)
15328               {
15329                 case 0x00:
15330                   goto op_semantics_119;
15331                   break;
15332               }
15333             break;
15334           case 0x28:
15335               GETBYTE ();
15336               switch (op[2] & 0x00)
15337               {
15338                 case 0x00:
15339                   goto op_semantics_119;
15340                   break;
15341               }
15342             break;
15343           case 0x29:
15344               GETBYTE ();
15345               switch (op[2] & 0x00)
15346               {
15347                 case 0x00:
15348                   goto op_semantics_119;
15349                   break;
15350               }
15351             break;
15352           case 0x2a:
15353               GETBYTE ();
15354               switch (op[2] & 0x00)
15355               {
15356                 case 0x00:
15357                   goto op_semantics_119;
15358                   break;
15359               }
15360             break;
15361           case 0x2b:
15362               GETBYTE ();
15363               switch (op[2] & 0x00)
15364               {
15365                 case 0x00:
15366                   goto op_semantics_119;
15367                   break;
15368               }
15369             break;
15370           case 0x2c:
15371               GETBYTE ();
15372               switch (op[2] & 0x00)
15373               {
15374                 case 0x00:
15375                   goto op_semantics_119;
15376                   break;
15377               }
15378             break;
15379           case 0x2d:
15380               GETBYTE ();
15381               switch (op[2] & 0x00)
15382               {
15383                 case 0x00:
15384                   goto op_semantics_119;
15385                   break;
15386               }
15387             break;
15388           case 0x2e:
15389               GETBYTE ();
15390               switch (op[2] & 0x00)
15391               {
15392                 case 0x00:
15393                   goto op_semantics_119;
15394                   break;
15395               }
15396             break;
15397           case 0x2f:
15398               GETBYTE ();
15399               switch (op[2] & 0x00)
15400               {
15401                 case 0x00:
15402                   goto op_semantics_119;
15403                   break;
15404               }
15405             break;
15406           case 0x30:
15407               GETBYTE ();
15408               switch (op[2] & 0x00)
15409               {
15410                 case 0x00:
15411                   op_semantics_120:
15412                     {
15413                       /** 1111 1111 0011 rdst srca srcb mul     %2, %1, %0 */
15414 #line 656 "rx-decode.opc"
15415                       int rdst AU = op[1] & 0x0f;
15416 #line 656 "rx-decode.opc"
15417                       int srca AU = (op[2] >> 4) & 0x0f;
15418 #line 656 "rx-decode.opc"
15419                       int srcb AU = op[2] & 0x0f;
15420                       if (trace)
15421                         {
15422                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15423                                  "/** 1111 1111 0011 rdst srca srcb     mul     %2, %1, %0 */",
15424                                  op[0], op[1], op[2]);
15425                           printf ("  rdst = 0x%x,", rdst);
15426                           printf ("  srca = 0x%x,", srca);
15427                           printf ("  srcb = 0x%x\n", srcb);
15428                         }
15429                       SYNTAX("mul       %2, %1, %0");
15430 #line 656 "rx-decode.opc"
15431                       ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
15432
15433                     /*----------------------------------------------------------------------*/
15434                     /* EMUL                                                                     */
15435
15436                     }
15437                   break;
15438               }
15439             break;
15440           case 0x31:
15441               GETBYTE ();
15442               switch (op[2] & 0x00)
15443               {
15444                 case 0x00:
15445                   goto op_semantics_120;
15446                   break;
15447               }
15448             break;
15449           case 0x32:
15450               GETBYTE ();
15451               switch (op[2] & 0x00)
15452               {
15453                 case 0x00:
15454                   goto op_semantics_120;
15455                   break;
15456               }
15457             break;
15458           case 0x33:
15459               GETBYTE ();
15460               switch (op[2] & 0x00)
15461               {
15462                 case 0x00:
15463                   goto op_semantics_120;
15464                   break;
15465               }
15466             break;
15467           case 0x34:
15468               GETBYTE ();
15469               switch (op[2] & 0x00)
15470               {
15471                 case 0x00:
15472                   goto op_semantics_120;
15473                   break;
15474               }
15475             break;
15476           case 0x35:
15477               GETBYTE ();
15478               switch (op[2] & 0x00)
15479               {
15480                 case 0x00:
15481                   goto op_semantics_120;
15482                   break;
15483               }
15484             break;
15485           case 0x36:
15486               GETBYTE ();
15487               switch (op[2] & 0x00)
15488               {
15489                 case 0x00:
15490                   goto op_semantics_120;
15491                   break;
15492               }
15493             break;
15494           case 0x37:
15495               GETBYTE ();
15496               switch (op[2] & 0x00)
15497               {
15498                 case 0x00:
15499                   goto op_semantics_120;
15500                   break;
15501               }
15502             break;
15503           case 0x38:
15504               GETBYTE ();
15505               switch (op[2] & 0x00)
15506               {
15507                 case 0x00:
15508                   goto op_semantics_120;
15509                   break;
15510               }
15511             break;
15512           case 0x39:
15513               GETBYTE ();
15514               switch (op[2] & 0x00)
15515               {
15516                 case 0x00:
15517                   goto op_semantics_120;
15518                   break;
15519               }
15520             break;
15521           case 0x3a:
15522               GETBYTE ();
15523               switch (op[2] & 0x00)
15524               {
15525                 case 0x00:
15526                   goto op_semantics_120;
15527                   break;
15528               }
15529             break;
15530           case 0x3b:
15531               GETBYTE ();
15532               switch (op[2] & 0x00)
15533               {
15534                 case 0x00:
15535                   goto op_semantics_120;
15536                   break;
15537               }
15538             break;
15539           case 0x3c:
15540               GETBYTE ();
15541               switch (op[2] & 0x00)
15542               {
15543                 case 0x00:
15544                   goto op_semantics_120;
15545                   break;
15546               }
15547             break;
15548           case 0x3d:
15549               GETBYTE ();
15550               switch (op[2] & 0x00)
15551               {
15552                 case 0x00:
15553                   goto op_semantics_120;
15554                   break;
15555               }
15556             break;
15557           case 0x3e:
15558               GETBYTE ();
15559               switch (op[2] & 0x00)
15560               {
15561                 case 0x00:
15562                   goto op_semantics_120;
15563                   break;
15564               }
15565             break;
15566           case 0x3f:
15567               GETBYTE ();
15568               switch (op[2] & 0x00)
15569               {
15570                 case 0x00:
15571                   goto op_semantics_120;
15572                   break;
15573               }
15574             break;
15575           case 0x40:
15576               GETBYTE ();
15577               switch (op[2] & 0x00)
15578               {
15579                 case 0x00:
15580                   op_semantics_121:
15581                     {
15582                       /** 1111 1111 0100 rdst srca srcb and     %2, %1, %0 */
15583 #line 426 "rx-decode.opc"
15584                       int rdst AU = op[1] & 0x0f;
15585 #line 426 "rx-decode.opc"
15586                       int srca AU = (op[2] >> 4) & 0x0f;
15587 #line 426 "rx-decode.opc"
15588                       int srcb AU = op[2] & 0x0f;
15589                       if (trace)
15590                         {
15591                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15592                                  "/** 1111 1111 0100 rdst srca srcb     and     %2, %1, %0 */",
15593                                  op[0], op[1], op[2]);
15594                           printf ("  rdst = 0x%x,", rdst);
15595                           printf ("  srca = 0x%x,", srca);
15596                           printf ("  srcb = 0x%x\n", srcb);
15597                         }
15598                       SYNTAX("and       %2, %1, %0");
15599 #line 426 "rx-decode.opc"
15600                       ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15601
15602                     /*----------------------------------------------------------------------*/
15603                     /* OR                                                                       */
15604
15605                     }
15606                   break;
15607               }
15608             break;
15609           case 0x41:
15610               GETBYTE ();
15611               switch (op[2] & 0x00)
15612               {
15613                 case 0x00:
15614                   goto op_semantics_121;
15615                   break;
15616               }
15617             break;
15618           case 0x42:
15619               GETBYTE ();
15620               switch (op[2] & 0x00)
15621               {
15622                 case 0x00:
15623                   goto op_semantics_121;
15624                   break;
15625               }
15626             break;
15627           case 0x43:
15628               GETBYTE ();
15629               switch (op[2] & 0x00)
15630               {
15631                 case 0x00:
15632                   goto op_semantics_121;
15633                   break;
15634               }
15635             break;
15636           case 0x44:
15637               GETBYTE ();
15638               switch (op[2] & 0x00)
15639               {
15640                 case 0x00:
15641                   goto op_semantics_121;
15642                   break;
15643               }
15644             break;
15645           case 0x45:
15646               GETBYTE ();
15647               switch (op[2] & 0x00)
15648               {
15649                 case 0x00:
15650                   goto op_semantics_121;
15651                   break;
15652               }
15653             break;
15654           case 0x46:
15655               GETBYTE ();
15656               switch (op[2] & 0x00)
15657               {
15658                 case 0x00:
15659                   goto op_semantics_121;
15660                   break;
15661               }
15662             break;
15663           case 0x47:
15664               GETBYTE ();
15665               switch (op[2] & 0x00)
15666               {
15667                 case 0x00:
15668                   goto op_semantics_121;
15669                   break;
15670               }
15671             break;
15672           case 0x48:
15673               GETBYTE ();
15674               switch (op[2] & 0x00)
15675               {
15676                 case 0x00:
15677                   goto op_semantics_121;
15678                   break;
15679               }
15680             break;
15681           case 0x49:
15682               GETBYTE ();
15683               switch (op[2] & 0x00)
15684               {
15685                 case 0x00:
15686                   goto op_semantics_121;
15687                   break;
15688               }
15689             break;
15690           case 0x4a:
15691               GETBYTE ();
15692               switch (op[2] & 0x00)
15693               {
15694                 case 0x00:
15695                   goto op_semantics_121;
15696                   break;
15697               }
15698             break;
15699           case 0x4b:
15700               GETBYTE ();
15701               switch (op[2] & 0x00)
15702               {
15703                 case 0x00:
15704                   goto op_semantics_121;
15705                   break;
15706               }
15707             break;
15708           case 0x4c:
15709               GETBYTE ();
15710               switch (op[2] & 0x00)
15711               {
15712                 case 0x00:
15713                   goto op_semantics_121;
15714                   break;
15715               }
15716             break;
15717           case 0x4d:
15718               GETBYTE ();
15719               switch (op[2] & 0x00)
15720               {
15721                 case 0x00:
15722                   goto op_semantics_121;
15723                   break;
15724               }
15725             break;
15726           case 0x4e:
15727               GETBYTE ();
15728               switch (op[2] & 0x00)
15729               {
15730                 case 0x00:
15731                   goto op_semantics_121;
15732                   break;
15733               }
15734             break;
15735           case 0x4f:
15736               GETBYTE ();
15737               switch (op[2] & 0x00)
15738               {
15739                 case 0x00:
15740                   goto op_semantics_121;
15741                   break;
15742               }
15743             break;
15744           case 0x50:
15745               GETBYTE ();
15746               switch (op[2] & 0x00)
15747               {
15748                 case 0x00:
15749                   op_semantics_122:
15750                     {
15751                       /** 1111 1111 0101 rdst srca srcb or      %2, %1, %0 */
15752 #line 444 "rx-decode.opc"
15753                       int rdst AU = op[1] & 0x0f;
15754 #line 444 "rx-decode.opc"
15755                       int srca AU = (op[2] >> 4) & 0x0f;
15756 #line 444 "rx-decode.opc"
15757                       int srcb AU = op[2] & 0x0f;
15758                       if (trace)
15759                         {
15760                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15761                                  "/** 1111 1111 0101 rdst srca srcb     or      %2, %1, %0 */",
15762                                  op[0], op[1], op[2]);
15763                           printf ("  rdst = 0x%x,", rdst);
15764                           printf ("  srca = 0x%x,", srca);
15765                           printf ("  srcb = 0x%x\n", srcb);
15766                         }
15767                       SYNTAX("or        %2, %1, %0");
15768 #line 444 "rx-decode.opc"
15769                       ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15770
15771                     /*----------------------------------------------------------------------*/
15772                     /* XOR                                                                      */
15773
15774                     }
15775                   break;
15776               }
15777             break;
15778           case 0x51:
15779               GETBYTE ();
15780               switch (op[2] & 0x00)
15781               {
15782                 case 0x00:
15783                   goto op_semantics_122;
15784                   break;
15785               }
15786             break;
15787           case 0x52:
15788               GETBYTE ();
15789               switch (op[2] & 0x00)
15790               {
15791                 case 0x00:
15792                   goto op_semantics_122;
15793                   break;
15794               }
15795             break;
15796           case 0x53:
15797               GETBYTE ();
15798               switch (op[2] & 0x00)
15799               {
15800                 case 0x00:
15801                   goto op_semantics_122;
15802                   break;
15803               }
15804             break;
15805           case 0x54:
15806               GETBYTE ();
15807               switch (op[2] & 0x00)
15808               {
15809                 case 0x00:
15810                   goto op_semantics_122;
15811                   break;
15812               }
15813             break;
15814           case 0x55:
15815               GETBYTE ();
15816               switch (op[2] & 0x00)
15817               {
15818                 case 0x00:
15819                   goto op_semantics_122;
15820                   break;
15821               }
15822             break;
15823           case 0x56:
15824               GETBYTE ();
15825               switch (op[2] & 0x00)
15826               {
15827                 case 0x00:
15828                   goto op_semantics_122;
15829                   break;
15830               }
15831             break;
15832           case 0x57:
15833               GETBYTE ();
15834               switch (op[2] & 0x00)
15835               {
15836                 case 0x00:
15837                   goto op_semantics_122;
15838                   break;
15839               }
15840             break;
15841           case 0x58:
15842               GETBYTE ();
15843               switch (op[2] & 0x00)
15844               {
15845                 case 0x00:
15846                   goto op_semantics_122;
15847                   break;
15848               }
15849             break;
15850           case 0x59:
15851               GETBYTE ();
15852               switch (op[2] & 0x00)
15853               {
15854                 case 0x00:
15855                   goto op_semantics_122;
15856                   break;
15857               }
15858             break;
15859           case 0x5a:
15860               GETBYTE ();
15861               switch (op[2] & 0x00)
15862               {
15863                 case 0x00:
15864                   goto op_semantics_122;
15865                   break;
15866               }
15867             break;
15868           case 0x5b:
15869               GETBYTE ();
15870               switch (op[2] & 0x00)
15871               {
15872                 case 0x00:
15873                   goto op_semantics_122;
15874                   break;
15875               }
15876             break;
15877           case 0x5c:
15878               GETBYTE ();
15879               switch (op[2] & 0x00)
15880               {
15881                 case 0x00:
15882                   goto op_semantics_122;
15883                   break;
15884               }
15885             break;
15886           case 0x5d:
15887               GETBYTE ();
15888               switch (op[2] & 0x00)
15889               {
15890                 case 0x00:
15891                   goto op_semantics_122;
15892                   break;
15893               }
15894             break;
15895           case 0x5e:
15896               GETBYTE ();
15897               switch (op[2] & 0x00)
15898               {
15899                 case 0x00:
15900                   goto op_semantics_122;
15901                   break;
15902               }
15903             break;
15904           case 0x5f:
15905               GETBYTE ();
15906               switch (op[2] & 0x00)
15907               {
15908                 case 0x00:
15909                   goto op_semantics_122;
15910                   break;
15911               }
15912             break;
15913           case 0x80:
15914               GETBYTE ();
15915               switch (op[2] & 0x00)
15916               {
15917                 case 0x00:
15918                   op_semantics_123:
15919                     {
15920                       /** 1111 1111 1000 rdst srca srcb fsub    %2, %1, %0 */
15921 #line 1104 "rx-decode.opc"
15922                       int rdst AU = op[1] & 0x0f;
15923 #line 1104 "rx-decode.opc"
15924                       int srca AU = (op[2] >> 4) & 0x0f;
15925 #line 1104 "rx-decode.opc"
15926                       int srcb AU = op[2] & 0x0f;
15927                       if (trace)
15928                         {
15929                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15930                                  "/** 1111 1111 1000 rdst srca srcb     fsub    %2, %1, %0 */",
15931                                  op[0], op[1], op[2]);
15932                           printf ("  rdst = 0x%x,", rdst);
15933                           printf ("  srca = 0x%x,", srca);
15934                           printf ("  srcb = 0x%x\n", srcb);
15935                         }
15936                       SYNTAX("fsub      %2, %1, %0");
15937 #line 1104 "rx-decode.opc"
15938                       ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15939
15940                     }
15941                   break;
15942               }
15943             break;
15944           case 0x81:
15945               GETBYTE ();
15946               switch (op[2] & 0x00)
15947               {
15948                 case 0x00:
15949                   goto op_semantics_123;
15950                   break;
15951               }
15952             break;
15953           case 0x82:
15954               GETBYTE ();
15955               switch (op[2] & 0x00)
15956               {
15957                 case 0x00:
15958                   goto op_semantics_123;
15959                   break;
15960               }
15961             break;
15962           case 0x83:
15963               GETBYTE ();
15964               switch (op[2] & 0x00)
15965               {
15966                 case 0x00:
15967                   goto op_semantics_123;
15968                   break;
15969               }
15970             break;
15971           case 0x84:
15972               GETBYTE ();
15973               switch (op[2] & 0x00)
15974               {
15975                 case 0x00:
15976                   goto op_semantics_123;
15977                   break;
15978               }
15979             break;
15980           case 0x85:
15981               GETBYTE ();
15982               switch (op[2] & 0x00)
15983               {
15984                 case 0x00:
15985                   goto op_semantics_123;
15986                   break;
15987               }
15988             break;
15989           case 0x86:
15990               GETBYTE ();
15991               switch (op[2] & 0x00)
15992               {
15993                 case 0x00:
15994                   goto op_semantics_123;
15995                   break;
15996               }
15997             break;
15998           case 0x87:
15999               GETBYTE ();
16000               switch (op[2] & 0x00)
16001               {
16002                 case 0x00:
16003                   goto op_semantics_123;
16004                   break;
16005               }
16006             break;
16007           case 0x88:
16008               GETBYTE ();
16009               switch (op[2] & 0x00)
16010               {
16011                 case 0x00:
16012                   goto op_semantics_123;
16013                   break;
16014               }
16015             break;
16016           case 0x89:
16017               GETBYTE ();
16018               switch (op[2] & 0x00)
16019               {
16020                 case 0x00:
16021                   goto op_semantics_123;
16022                   break;
16023               }
16024             break;
16025           case 0x8a:
16026               GETBYTE ();
16027               switch (op[2] & 0x00)
16028               {
16029                 case 0x00:
16030                   goto op_semantics_123;
16031                   break;
16032               }
16033             break;
16034           case 0x8b:
16035               GETBYTE ();
16036               switch (op[2] & 0x00)
16037               {
16038                 case 0x00:
16039                   goto op_semantics_123;
16040                   break;
16041               }
16042             break;
16043           case 0x8c:
16044               GETBYTE ();
16045               switch (op[2] & 0x00)
16046               {
16047                 case 0x00:
16048                   goto op_semantics_123;
16049                   break;
16050               }
16051             break;
16052           case 0x8d:
16053               GETBYTE ();
16054               switch (op[2] & 0x00)
16055               {
16056                 case 0x00:
16057                   goto op_semantics_123;
16058                   break;
16059               }
16060             break;
16061           case 0x8e:
16062               GETBYTE ();
16063               switch (op[2] & 0x00)
16064               {
16065                 case 0x00:
16066                   goto op_semantics_123;
16067                   break;
16068               }
16069             break;
16070           case 0x8f:
16071               GETBYTE ();
16072               switch (op[2] & 0x00)
16073               {
16074                 case 0x00:
16075                   goto op_semantics_123;
16076                   break;
16077               }
16078             break;
16079           case 0xa0:
16080               GETBYTE ();
16081               switch (op[2] & 0x00)
16082               {
16083                 case 0x00:
16084                   op_semantics_124:
16085                     {
16086                       /** 1111 1111 1010 rdst srca srcb fadd    %2, %1, %0 */
16087 #line 1101 "rx-decode.opc"
16088                       int rdst AU = op[1] & 0x0f;
16089 #line 1101 "rx-decode.opc"
16090                       int srca AU = (op[2] >> 4) & 0x0f;
16091 #line 1101 "rx-decode.opc"
16092                       int srcb AU = op[2] & 0x0f;
16093                       if (trace)
16094                         {
16095                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16096                                  "/** 1111 1111 1010 rdst srca srcb     fadd    %2, %1, %0 */",
16097                                  op[0], op[1], op[2]);
16098                           printf ("  rdst = 0x%x,", rdst);
16099                           printf ("  srca = 0x%x,", srca);
16100                           printf ("  srcb = 0x%x\n", srcb);
16101                         }
16102                       SYNTAX("fadd      %2, %1, %0");
16103 #line 1101 "rx-decode.opc"
16104                       ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
16105
16106                     }
16107                   break;
16108               }
16109             break;
16110           case 0xa1:
16111               GETBYTE ();
16112               switch (op[2] & 0x00)
16113               {
16114                 case 0x00:
16115                   goto op_semantics_124;
16116                   break;
16117               }
16118             break;
16119           case 0xa2:
16120               GETBYTE ();
16121               switch (op[2] & 0x00)
16122               {
16123                 case 0x00:
16124                   goto op_semantics_124;
16125                   break;
16126               }
16127             break;
16128           case 0xa3:
16129               GETBYTE ();
16130               switch (op[2] & 0x00)
16131               {
16132                 case 0x00:
16133                   goto op_semantics_124;
16134                   break;
16135               }
16136             break;
16137           case 0xa4:
16138               GETBYTE ();
16139               switch (op[2] & 0x00)
16140               {
16141                 case 0x00:
16142                   goto op_semantics_124;
16143                   break;
16144               }
16145             break;
16146           case 0xa5:
16147               GETBYTE ();
16148               switch (op[2] & 0x00)
16149               {
16150                 case 0x00:
16151                   goto op_semantics_124;
16152                   break;
16153               }
16154             break;
16155           case 0xa6:
16156               GETBYTE ();
16157               switch (op[2] & 0x00)
16158               {
16159                 case 0x00:
16160                   goto op_semantics_124;
16161                   break;
16162               }
16163             break;
16164           case 0xa7:
16165               GETBYTE ();
16166               switch (op[2] & 0x00)
16167               {
16168                 case 0x00:
16169                   goto op_semantics_124;
16170                   break;
16171               }
16172             break;
16173           case 0xa8:
16174               GETBYTE ();
16175               switch (op[2] & 0x00)
16176               {
16177                 case 0x00:
16178                   goto op_semantics_124;
16179                   break;
16180               }
16181             break;
16182           case 0xa9:
16183               GETBYTE ();
16184               switch (op[2] & 0x00)
16185               {
16186                 case 0x00:
16187                   goto op_semantics_124;
16188                   break;
16189               }
16190             break;
16191           case 0xaa:
16192               GETBYTE ();
16193               switch (op[2] & 0x00)
16194               {
16195                 case 0x00:
16196                   goto op_semantics_124;
16197                   break;
16198               }
16199             break;
16200           case 0xab:
16201               GETBYTE ();
16202               switch (op[2] & 0x00)
16203               {
16204                 case 0x00:
16205                   goto op_semantics_124;
16206                   break;
16207               }
16208             break;
16209           case 0xac:
16210               GETBYTE ();
16211               switch (op[2] & 0x00)
16212               {
16213                 case 0x00:
16214                   goto op_semantics_124;
16215                   break;
16216               }
16217             break;
16218           case 0xad:
16219               GETBYTE ();
16220               switch (op[2] & 0x00)
16221               {
16222                 case 0x00:
16223                   goto op_semantics_124;
16224                   break;
16225               }
16226             break;
16227           case 0xae:
16228               GETBYTE ();
16229               switch (op[2] & 0x00)
16230               {
16231                 case 0x00:
16232                   goto op_semantics_124;
16233                   break;
16234               }
16235             break;
16236           case 0xaf:
16237               GETBYTE ();
16238               switch (op[2] & 0x00)
16239               {
16240                 case 0x00:
16241                   goto op_semantics_124;
16242                   break;
16243               }
16244             break;
16245           case 0xb0:
16246               GETBYTE ();
16247               switch (op[2] & 0x00)
16248               {
16249                 case 0x00:
16250                   op_semantics_125:
16251                     {
16252                       /** 1111 1111 1011 rdst srca srcb fmul    %2, %1, %0 */
16253 #line 1107 "rx-decode.opc"
16254                       int rdst AU = op[1] & 0x0f;
16255 #line 1107 "rx-decode.opc"
16256                       int srca AU = (op[2] >> 4) & 0x0f;
16257 #line 1107 "rx-decode.opc"
16258                       int srcb AU = op[2] & 0x0f;
16259                       if (trace)
16260                         {
16261                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16262                                  "/** 1111 1111 1011 rdst srca srcb     fmul    %2, %1, %0 */",
16263                                  op[0], op[1], op[2]);
16264                           printf ("  rdst = 0x%x,", rdst);
16265                           printf ("  srca = 0x%x,", srca);
16266                           printf ("  srcb = 0x%x\n", srcb);
16267                         }
16268                       SYNTAX("fmul      %2, %1, %0");
16269 #line 1107 "rx-decode.opc"
16270                       ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
16271
16272                     }
16273                   break;
16274               }
16275             break;
16276           case 0xb1:
16277               GETBYTE ();
16278               switch (op[2] & 0x00)
16279               {
16280                 case 0x00:
16281                   goto op_semantics_125;
16282                   break;
16283               }
16284             break;
16285           case 0xb2:
16286               GETBYTE ();
16287               switch (op[2] & 0x00)
16288               {
16289                 case 0x00:
16290                   goto op_semantics_125;
16291                   break;
16292               }
16293             break;
16294           case 0xb3:
16295               GETBYTE ();
16296               switch (op[2] & 0x00)
16297               {
16298                 case 0x00:
16299                   goto op_semantics_125;
16300                   break;
16301               }
16302             break;
16303           case 0xb4:
16304               GETBYTE ();
16305               switch (op[2] & 0x00)
16306               {
16307                 case 0x00:
16308                   goto op_semantics_125;
16309                   break;
16310               }
16311             break;
16312           case 0xb5:
16313               GETBYTE ();
16314               switch (op[2] & 0x00)
16315               {
16316                 case 0x00:
16317                   goto op_semantics_125;
16318                   break;
16319               }
16320             break;
16321           case 0xb6:
16322               GETBYTE ();
16323               switch (op[2] & 0x00)
16324               {
16325                 case 0x00:
16326                   goto op_semantics_125;
16327                   break;
16328               }
16329             break;
16330           case 0xb7:
16331               GETBYTE ();
16332               switch (op[2] & 0x00)
16333               {
16334                 case 0x00:
16335                   goto op_semantics_125;
16336                   break;
16337               }
16338             break;
16339           case 0xb8:
16340               GETBYTE ();
16341               switch (op[2] & 0x00)
16342               {
16343                 case 0x00:
16344                   goto op_semantics_125;
16345                   break;
16346               }
16347             break;
16348           case 0xb9:
16349               GETBYTE ();
16350               switch (op[2] & 0x00)
16351               {
16352                 case 0x00:
16353                   goto op_semantics_125;
16354                   break;
16355               }
16356             break;
16357           case 0xba:
16358               GETBYTE ();
16359               switch (op[2] & 0x00)
16360               {
16361                 case 0x00:
16362                   goto op_semantics_125;
16363                   break;
16364               }
16365             break;
16366           case 0xbb:
16367               GETBYTE ();
16368               switch (op[2] & 0x00)
16369               {
16370                 case 0x00:
16371                   goto op_semantics_125;
16372                   break;
16373               }
16374             break;
16375           case 0xbc:
16376               GETBYTE ();
16377               switch (op[2] & 0x00)
16378               {
16379                 case 0x00:
16380                   goto op_semantics_125;
16381                   break;
16382               }
16383             break;
16384           case 0xbd:
16385               GETBYTE ();
16386               switch (op[2] & 0x00)
16387               {
16388                 case 0x00:
16389                   goto op_semantics_125;
16390                   break;
16391               }
16392             break;
16393           case 0xbe:
16394               GETBYTE ();
16395               switch (op[2] & 0x00)
16396               {
16397                 case 0x00:
16398                   goto op_semantics_125;
16399                   break;
16400               }
16401             break;
16402           case 0xbf:
16403               GETBYTE ();
16404               switch (op[2] & 0x00)
16405               {
16406                 case 0x00:
16407                   goto op_semantics_125;
16408                   break;
16409               }
16410             break;
16411           default: UNSUPPORTED(); break;
16412         }
16413       break;
16414     default: UNSUPPORTED(); break;
16415   }
16416 #line 1122 "rx-decode.opc"
16417
16418   return rx->n_bytes;
16419 }