opcodes/rx-decode.c

   1 /* DO NOT EDIT!  -*- buffer-read-only: t -*- vi:set ro:  */
   2 #line 1 "rx-decode.opc"
   3 /* -*- c -*- */
   4 /* Copyright (C) 2012-2018 Free Software Foundation, Inc.
   5    Contributed by Red Hat.
   6    Written by DJ Delorie.
   7
   8    This file is part of the GNU opcodes library.
   9
  10    This library is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3, or (at your option)
  13    any later version.
  14
  15    It is distributed in the hope that it will be useful, but WITHOUT
  16    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  17    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  18    License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  23    MA 02110-1301, USA.  */
  24
  25 #include "sysdep.h"
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include "ansidecl.h"
  30 #include "opcode/rx.h"
  31 #include "libiberty.h"
  32
  33 #define RX_OPCODE_BIG_ENDIAN 0
  34
  35 typedef struct
  36 {
  37   RX_Opcode_Decoded * rx;
  38   int (* getbyte)(void *);
  39   void * ptr;
  40   unsigned char * op;
  41 } LocalData;
  42
  43 static int trace = 0;
  44
  45 #define BSIZE 0
  46 #define WSIZE 1
  47 #define LSIZE 2
  48
  49 /* These are for when the upper bits are "don't care" or "undefined".  */
  50 static int bwl[4] =
  51 {
  52   RX_Byte,
  53   RX_Word,
  54   RX_Long,
  55   RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
  56 };
  57
  58 static int sbwl[4] =
  59 {
  60   RX_SByte,
  61   RX_SWord,
  62   RX_Long,
  63   RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
  64 };
  65
  66 static int ubw[4] =
  67 {
  68   RX_UByte,
  69   RX_UWord,
  70   RX_Bad_Size,/* Bogus instructions can have a size field set to 2.  */
  71   RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
  72 };
  73
  74 static int memex[4] =
  75 {
  76   RX_SByte,
  77   RX_SWord,
  78   RX_Long,
  79   RX_UWord
  80 };
  81
  82 #define ID(x) rx->id = RXO_##x
  83 #define OP(n,t,r,a) (rx->op[n].type = t, \
  84                      rx->op[n].reg = r,      \
  85                      rx->op[n].addend = a )
  86 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
  87                         rx->op[n].size = s )
  88
  89 /* This is for the BWL and BW bitfields.  */
  90 static int SCALE[] = { 1, 2, 4, 0 };
  91 /* This is for the prefix size enum.  */
  92 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
  93
  94 #define GET_SCALE(_indx)  ((unsigned)(_indx) < ARRAY_SIZE (SCALE) ? SCALE[(_indx)] : 0)
  95 #define GET_PSCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (PSCALE) ? PSCALE[(_indx)] : 0)
  96
  97 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
  98                        16, 17, 0, 0, 0, 0, 0, 0 };
  99
 100 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
 101
 102 /*
 103  *C     a constant (immediate) c
 104  *R     A register
 105  *I     Register indirect, no offset
 106  *Is    Register indirect, with offset
 107  *D     standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
 108  *P     standard displacement: type (r,[r]), reg, assumes UByte
 109  *Pm    memex displacement: type (r,[r]), reg, memex code
 110  *cc    condition code.  */
 111
 112 #define DC(c)       OP (0, RX_Operand_Immediate, 0, c)
 113 #define DR(r)       OP (0, RX_Operand_Register,  r, 0)
 114 #define DI(r,a)     OP (0, RX_Operand_Indirect,  r, a)
 115 #define DIs(r,a,s)  OP (0, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))
 116 #define DD(t,r,s)   rx_disp (0, t, r, bwl[s], ld);
 117 #define DF(r)       OP (0, RX_Operand_Flag,  flagmap[r], 0)
 118
 119 #define SC(i)       OP (1, RX_Operand_Immediate, 0, i)
 120 #define SR(r)       OP (1, RX_Operand_Register,  r, 0)
 121 #define SRR(r)      OP (1, RX_Operand_TwoReg,  r, 0)
 122 #define SI(r,a)     OP (1, RX_Operand_Indirect,  r, a)
 123 #define SIs(r,a,s)  OP (1, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))
 124 #define SD(t,r,s)   rx_disp (1, t, r, bwl[s], ld);
 125 #define SP(t,r)     rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
 126 #define SPm(t,r,m)  rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
 127 #define Scc(cc)     OP (1, RX_Operand_Condition,  cc, 0)
 128
 129 #define S2C(i)      OP (2, RX_Operand_Immediate, 0, i)
 130 #define S2R(r)      OP (2, RX_Operand_Register,  r, 0)
 131 #define S2I(r,a)    OP (2, RX_Operand_Indirect,  r, a)
 132 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))
 133 #define S2D(t,r,s)  rx_disp (2, t, r, bwl[s], ld);
 134 #define S2P(t,r)    rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
 135 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
 136 #define S2cc(cc)    OP (2, RX_Operand_Condition,  cc, 0)
 137
 138 #define BWL(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
 139 #define sBWL(sz)    rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
 140 #define uBW(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
 141 #define P(t, n)     rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
 142
 143 #define F(f) store_flags(rx, f)
 144
 145 #define AU ATTRIBUTE_UNUSED
 146 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
 147
 148 #define SYNTAX(x) rx->syntax = x
 149
 150 #define UNSUPPORTED() \
 151   rx->syntax = "*unknown*"
 152
 153 #define IMM(sf)   immediate (sf, 0, ld)
 154 #define IMMex(sf) immediate (sf, 1, ld)
 155
 156 static int
 157 immediate (int sfield, int ex, LocalData * ld)
 158 {
 159   unsigned long i = 0, j;
 160
 161   switch (sfield)
 162     {
 163 #define B ((unsigned long) GETBYTE())
 164     case 0:
 165 #if RX_OPCODE_BIG_ENDIAN
 166       i  = B;
 167       if (ex && (i & 0x80))
 168         i -= 0x100;
 169       i <<= 24;
 170       i |= B << 16;
 171       i |= B << 8;
 172       i |= B;
 173 #else
 174       i = B;
 175       i |= B << 8;
 176       i |= B << 16;
 177       j = B;
 178       if (ex && (j & 0x80))
 179         j -= 0x100;
 180       i |= j << 24;
 181 #endif
 182       break;
 183     case 3:
 184 #if RX_OPCODE_BIG_ENDIAN
 185       i  = B << 16;
 186       i |= B << 8;
 187       i |= B;
 188 #else
 189       i  = B;
 190       i |= B << 8;
 191       i |= B << 16;
 192 #endif
 193       if (ex && (i & 0x800000))
 194         i -= 0x1000000;
 195       break;
 196     case 2:
 197 #if RX_OPCODE_BIG_ENDIAN
 198       i |= B << 8;
 199       i |= B;
 200 #else
 201       i |= B;
 202       i |= B << 8;
 203 #endif
 204       if (ex && (i & 0x8000))
 205         i -= 0x10000;
 206       break;
 207     case 1:
 208       i |= B;
 209       if (ex && (i & 0x80))
 210         i -= 0x100;
 211       break;
 212     default:
 213       abort();
 214     }
 215   return i;
 216 }
 217
 218 static void
 219 rx_disp (int n, int type, int reg, unsigned int size, LocalData * ld)
 220 {
 221   int disp;
 222
 223   ld->rx->op[n].reg = reg;
 224   switch (type)
 225     {
 226     case 3:
 227       ld->rx->op[n].type = RX_Operand_Register;
 228       break;
 229     case 0:
 230       ld->rx->op[n].type = RX_Operand_Zero_Indirect;
 231       ld->rx->op[n].addend = 0;
 232       break;
 233     case 1:
 234       ld->rx->op[n].type = RX_Operand_Indirect;
 235       disp = GETBYTE ();
 236       ld->rx->op[n].addend = disp * GET_PSCALE (size);
 237       break;
 238     case 2:
 239       ld->rx->op[n].type = RX_Operand_Indirect;
 240       disp = GETBYTE ();
 241 #if RX_OPCODE_BIG_ENDIAN
 242       disp = disp * 256 + GETBYTE ();
 243 #else
 244       disp = disp + GETBYTE () * 256;
 245 #endif
 246       ld->rx->op[n].addend = disp * GET_PSCALE (size);
 247       break;
 248     default:
 249       abort ();
 250     }
 251 }
 252
 253 #define xO 8
 254 #define xS 4
 255 #define xZ 2
 256 #define xC 1
 257
 258 #define F_____
 259 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
 260 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
 261 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
 262 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
 263 #define F_O___ rx->flags_0 = rx->flags_s = xO;
 264 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
 265 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
 266 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
 267
 268 int
 269 rx_decode_opcode (unsigned long pc AU,
 270                   RX_Opcode_Decoded * rx,
 271                   int (* getbyte)(void *),
 272                   void * ptr)
 273 {
 274   LocalData lds, * ld = &lds;
 275   unsigned char op[20] = {0};
 276
 277   lds.rx = rx;
 278   lds.getbyte = getbyte;
 279   lds.ptr = ptr;
 280   lds.op = op;
 281
 282   memset (rx, 0, sizeof (*rx));
 283   BWL(LSIZE);
 284
 285
 286 /*----------------------------------------------------------------------*/
 287 /* MOV                                                                  */
 288
 289   GETBYTE ();
 290   switch (op[0] & 0xff)
 291   {
 292     case 0x00:
 293         {
 294           /** 0000 0000                 brk */
 295           if (trace)
 296             {
 297               printf ("\033[33m%s\033[0m  %02x\n",
 298                      "/** 0000 0000                     brk */",
 299                      op[0]);
 300             }
 301           SYNTAX("brk");
 302 #line 1029 "rx-decode.opc"
 303           ID(brk);
 304
 305         }
 306       break;
 307     case 0x01:
 308         {
 309           /** 0000 0001                 dbt */
 310           if (trace)
 311             {
 312               printf ("\033[33m%s\033[0m  %02x\n",
 313                      "/** 0000 0001                     dbt */",
 314                      op[0]);
 315             }
 316           SYNTAX("dbt");
 317 #line 1032 "rx-decode.opc"
 318           ID(dbt);
 319
 320         }
 321       break;
 322     case 0x02:
 323         {
 324           /** 0000 0010                 rts */
 325           if (trace)
 326             {
 327               printf ("\033[33m%s\033[0m  %02x\n",
 328                      "/** 0000 0010                     rts */",
 329                      op[0]);
 330             }
 331           SYNTAX("rts");
 332 #line 810 "rx-decode.opc"
 333           ID(rts);
 334
 335         /*----------------------------------------------------------------------*/
 336         /* NOP                                                          */
 337
 338         }
 339       break;
 340     case 0x03:
 341         {
 342           /** 0000 0011                 nop */
 343           if (trace)
 344             {
 345               printf ("\033[33m%s\033[0m  %02x\n",
 346                      "/** 0000 0011                     nop */",
 347                      op[0]);
 348             }
 349           SYNTAX("nop");
 350 #line 816 "rx-decode.opc"
 351           ID(nop);
 352
 353         /*----------------------------------------------------------------------*/
 354         /* STRING FUNCTIONS                                                     */
 355
 356         }
 357       break;
 358     case 0x04:
 359         {
 360           /** 0000 0100                 bra.a   %a0 */
 361           if (trace)
 362             {
 363               printf ("\033[33m%s\033[0m  %02x\n",
 364                      "/** 0000 0100                     bra.a   %a0 */",
 365                      op[0]);
 366             }
 367           SYNTAX("bra.a %a0");
 368 #line 788 "rx-decode.opc"
 369           ID(branch); DC(pc + IMMex(3));
 370
 371         }
 372       break;
 373     case 0x05:
 374         {
 375           /** 0000 0101                 bsr.a   %a0 */
 376           if (trace)
 377             {
 378               printf ("\033[33m%s\033[0m  %02x\n",
 379                      "/** 0000 0101                     bsr.a   %a0 */",
 380                      op[0]);
 381             }
 382           SYNTAX("bsr.a %a0");
 383 #line 804 "rx-decode.opc"
 384           ID(jsr); DC(pc + IMMex(3));
 385
 386         }
 387       break;
 388     case 0x06:
 389         GETBYTE ();
 390         switch (op[1] & 0xff)
 391         {
 392           case 0x00:
 393               GETBYTE ();
 394               switch (op[2] & 0x00)
 395               {
 396                 case 0x00:
 397                   op_semantics_1:
 398                     {
 399                       /** 0000 0110 mx00 00ss rsrc rdst                 sub     %2%S2, %1 */
 400 #line 546 "rx-decode.opc"
 401                       int mx AU = (op[1] >> 6) & 0x03;
 402 #line 546 "rx-decode.opc"
 403                       int ss AU = op[1] & 0x03;
 404 #line 546 "rx-decode.opc"
 405                       int rsrc AU = (op[2] >> 4) & 0x0f;
 406 #line 546 "rx-decode.opc"
 407                       int rdst AU = op[2] & 0x0f;
 408                       if (trace)
 409                         {
 410                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 411                                  "/** 0000 0110 mx00 00ss rsrc rdst                     sub     %2%S2, %1 */",
 412                                  op[0], op[1], op[2]);
 413                           printf ("  mx = 0x%x,", mx);
 414                           printf ("  ss = 0x%x,", ss);
 415                           printf ("  rsrc = 0x%x,", rsrc);
 416                           printf ("  rdst = 0x%x\n", rdst);
 417                         }
 418                       SYNTAX("sub       %2%S2, %1");
 419 #line 546 "rx-decode.opc"
 420                       ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
 421
 422                     }
 423                   break;
 424               }
 425             break;
 426           case 0x01:
 427               GETBYTE ();
 428               switch (op[2] & 0x00)
 429               {
 430                 case 0x00:
 431                   goto op_semantics_1;
 432                   break;
 433               }
 434             break;
 435           case 0x02:
 436               GETBYTE ();
 437               switch (op[2] & 0x00)
 438               {
 439                 case 0x00:
 440                   goto op_semantics_1;
 441                   break;
 442               }
 443             break;
 444           case 0x03:
 445               GETBYTE ();
 446               switch (op[2] & 0x00)
 447               {
 448                 case 0x00:
 449                   goto op_semantics_1;
 450                   break;
 451               }
 452             break;
 453           case 0x04:
 454               GETBYTE ();
 455               switch (op[2] & 0x00)
 456               {
 457                 case 0x00:
 458                   op_semantics_2:
 459                     {
 460                       /** 0000 0110 mx00 01ss rsrc rdst         cmp     %2%S2, %1 */
 461 #line 534 "rx-decode.opc"
 462                       int mx AU = (op[1] >> 6) & 0x03;
 463 #line 534 "rx-decode.opc"
 464                       int ss AU = op[1] & 0x03;
 465 #line 534 "rx-decode.opc"
 466                       int rsrc AU = (op[2] >> 4) & 0x0f;
 467 #line 534 "rx-decode.opc"
 468                       int rdst AU = op[2] & 0x0f;
 469                       if (trace)
 470                         {
 471                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 472                                  "/** 0000 0110 mx00 01ss rsrc rdst             cmp     %2%S2, %1 */",
 473                                  op[0], op[1], op[2]);
 474                           printf ("  mx = 0x%x,", mx);
 475                           printf ("  ss = 0x%x,", ss);
 476                           printf ("  rsrc = 0x%x,", rsrc);
 477                           printf ("  rdst = 0x%x\n", rdst);
 478                         }
 479                       SYNTAX("cmp       %2%S2, %1");
 480 #line 534 "rx-decode.opc"
 481                       ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
 482
 483                     /*----------------------------------------------------------------------*/
 484                     /* SUB                                                                      */
 485
 486                     }
 487                   break;
 488               }
 489             break;
 490           case 0x05:
 491               GETBYTE ();
 492               switch (op[2] & 0x00)
 493               {
 494                 case 0x00:
 495                   goto op_semantics_2;
 496                   break;
 497               }
 498             break;
 499           case 0x06:
 500               GETBYTE ();
 501               switch (op[2] & 0x00)
 502               {
 503                 case 0x00:
 504                   goto op_semantics_2;
 505                   break;
 506               }
 507             break;
 508           case 0x07:
 509               GETBYTE ();
 510               switch (op[2] & 0x00)
 511               {
 512                 case 0x00:
 513                   goto op_semantics_2;
 514                   break;
 515               }
 516             break;
 517           case 0x08:
 518               GETBYTE ();
 519               switch (op[2] & 0x00)
 520               {
 521                 case 0x00:
 522                   op_semantics_3:
 523                     {
 524                       /** 0000 0110 mx00 10ss rsrc rdst add     %1%S1, %0 */
 525 #line 510 "rx-decode.opc"
 526                       int mx AU = (op[1] >> 6) & 0x03;
 527 #line 510 "rx-decode.opc"
 528                       int ss AU = op[1] & 0x03;
 529 #line 510 "rx-decode.opc"
 530                       int rsrc AU = (op[2] >> 4) & 0x0f;
 531 #line 510 "rx-decode.opc"
 532                       int rdst AU = op[2] & 0x0f;
 533                       if (trace)
 534                         {
 535                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 536                                  "/** 0000 0110 mx00 10ss rsrc rdst     add     %1%S1, %0 */",
 537                                  op[0], op[1], op[2]);
 538                           printf ("  mx = 0x%x,", mx);
 539                           printf ("  ss = 0x%x,", ss);
 540                           printf ("  rsrc = 0x%x,", rsrc);
 541                           printf ("  rdst = 0x%x\n", rdst);
 542                         }
 543                       SYNTAX("add       %1%S1, %0");
 544 #line 510 "rx-decode.opc"
 545                       ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
 546
 547                     }
 548                   break;
 549               }
 550             break;
 551           case 0x09:
 552               GETBYTE ();
 553               switch (op[2] & 0x00)
 554               {
 555                 case 0x00:
 556                   goto op_semantics_3;
 557                   break;
 558               }
 559             break;
 560           case 0x0a:
 561               GETBYTE ();
 562               switch (op[2] & 0x00)
 563               {
 564                 case 0x00:
 565                   goto op_semantics_3;
 566                   break;
 567               }
 568             break;
 569           case 0x0b:
 570               GETBYTE ();
 571               switch (op[2] & 0x00)
 572               {
 573                 case 0x00:
 574                   goto op_semantics_3;
 575                   break;
 576               }
 577             break;
 578           case 0x0c:
 579               GETBYTE ();
 580               switch (op[2] & 0x00)
 581               {
 582                 case 0x00:
 583                   op_semantics_4:
 584                     {
 585                       /** 0000 0110 mx00 11ss rsrc rdst mul     %1%S1, %0 */
 586 #line 653 "rx-decode.opc"
 587                       int mx AU = (op[1] >> 6) & 0x03;
 588 #line 653 "rx-decode.opc"
 589                       int ss AU = op[1] & 0x03;
 590 #line 653 "rx-decode.opc"
 591                       int rsrc AU = (op[2] >> 4) & 0x0f;
 592 #line 653 "rx-decode.opc"
 593                       int rdst AU = op[2] & 0x0f;
 594                       if (trace)
 595                         {
 596                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 597                                  "/** 0000 0110 mx00 11ss rsrc rdst     mul     %1%S1, %0 */",
 598                                  op[0], op[1], op[2]);
 599                           printf ("  mx = 0x%x,", mx);
 600                           printf ("  ss = 0x%x,", ss);
 601                           printf ("  rsrc = 0x%x,", rsrc);
 602                           printf ("  rdst = 0x%x\n", rdst);
 603                         }
 604                       SYNTAX("mul       %1%S1, %0");
 605 #line 653 "rx-decode.opc"
 606                       ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
 607
 608                     }
 609                   break;
 610               }
 611             break;
 612           case 0x0d:
 613               GETBYTE ();
 614               switch (op[2] & 0x00)
 615               {
 616                 case 0x00:
 617                   goto op_semantics_4;
 618                   break;
 619               }
 620             break;
 621           case 0x0e:
 622               GETBYTE ();
 623               switch (op[2] & 0x00)
 624               {
 625                 case 0x00:
 626                   goto op_semantics_4;
 627                   break;
 628               }
 629             break;
 630           case 0x0f:
 631               GETBYTE ();
 632               switch (op[2] & 0x00)
 633               {
 634                 case 0x00:
 635                   goto op_semantics_4;
 636                   break;
 637               }
 638             break;
 639           case 0x10:
 640               GETBYTE ();
 641               switch (op[2] & 0x00)
 642               {
 643                 case 0x00:
 644                   op_semantics_5:
 645                     {
 646                       /** 0000 0110 mx01 00ss rsrc rdst and     %1%S1, %0 */
 647 #line 423 "rx-decode.opc"
 648                       int mx AU = (op[1] >> 6) & 0x03;
 649 #line 423 "rx-decode.opc"
 650                       int ss AU = op[1] & 0x03;
 651 #line 423 "rx-decode.opc"
 652                       int rsrc AU = (op[2] >> 4) & 0x0f;
 653 #line 423 "rx-decode.opc"
 654                       int rdst AU = op[2] & 0x0f;
 655                       if (trace)
 656                         {
 657                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 658                                  "/** 0000 0110 mx01 00ss rsrc rdst     and     %1%S1, %0 */",
 659                                  op[0], op[1], op[2]);
 660                           printf ("  mx = 0x%x,", mx);
 661                           printf ("  ss = 0x%x,", ss);
 662                           printf ("  rsrc = 0x%x,", rsrc);
 663                           printf ("  rdst = 0x%x\n", rdst);
 664                         }
 665                       SYNTAX("and       %1%S1, %0");
 666 #line 423 "rx-decode.opc"
 667                       ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
 668
 669                     }
 670                   break;
 671               }
 672             break;
 673           case 0x11:
 674               GETBYTE ();
 675               switch (op[2] & 0x00)
 676               {
 677                 case 0x00:
 678                   goto op_semantics_5;
 679                   break;
 680               }
 681             break;
 682           case 0x12:
 683               GETBYTE ();
 684               switch (op[2] & 0x00)
 685               {
 686                 case 0x00:
 687                   goto op_semantics_5;
 688                   break;
 689               }
 690             break;
 691           case 0x13:
 692               GETBYTE ();
 693               switch (op[2] & 0x00)
 694               {
 695                 case 0x00:
 696                   goto op_semantics_5;
 697                   break;
 698               }
 699             break;
 700           case 0x14:
 701               GETBYTE ();
 702               switch (op[2] & 0x00)
 703               {
 704                 case 0x00:
 705                   op_semantics_6:
 706                     {
 707                       /** 0000 0110 mx01 01ss rsrc rdst                 or      %1%S1, %0 */
 708 #line 441 "rx-decode.opc"
 709                       int mx AU = (op[1] >> 6) & 0x03;
 710 #line 441 "rx-decode.opc"
 711                       int ss AU = op[1] & 0x03;
 712 #line 441 "rx-decode.opc"
 713                       int rsrc AU = (op[2] >> 4) & 0x0f;
 714 #line 441 "rx-decode.opc"
 715                       int rdst AU = op[2] & 0x0f;
 716                       if (trace)
 717                         {
 718                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 719                                  "/** 0000 0110 mx01 01ss rsrc rdst                     or      %1%S1, %0 */",
 720                                  op[0], op[1], op[2]);
 721                           printf ("  mx = 0x%x,", mx);
 722                           printf ("  ss = 0x%x,", ss);
 723                           printf ("  rsrc = 0x%x,", rsrc);
 724                           printf ("  rdst = 0x%x\n", rdst);
 725                         }
 726                       SYNTAX("or        %1%S1, %0");
 727 #line 441 "rx-decode.opc"
 728                       ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
 729
 730                     }
 731                   break;
 732               }
 733             break;
 734           case 0x15:
 735               GETBYTE ();
 736               switch (op[2] & 0x00)
 737               {
 738                 case 0x00:
 739                   goto op_semantics_6;
 740                   break;
 741               }
 742             break;
 743           case 0x16:
 744               GETBYTE ();
 745               switch (op[2] & 0x00)
 746               {
 747                 case 0x00:
 748                   goto op_semantics_6;
 749                   break;
 750               }
 751             break;
 752           case 0x17:
 753               GETBYTE ();
 754               switch (op[2] & 0x00)
 755               {
 756                 case 0x00:
 757                   goto op_semantics_6;
 758                   break;
 759               }
 760             break;
 761           case 0x20:
 762               GETBYTE ();
 763               switch (op[2] & 0xff)
 764               {
 765                 case 0x00:
 766                     GETBYTE ();
 767                     switch (op[3] & 0x00)
 768                     {
 769                       case 0x00:
 770                         op_semantics_7:
 771                           {
 772                             /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb     %1%S1, %0 */
 773 #line 559 "rx-decode.opc"
 774                             int mx AU = (op[1] >> 6) & 0x03;
 775 #line 559 "rx-decode.opc"
 776                             int sp AU = op[1] & 0x03;
 777 #line 559 "rx-decode.opc"
 778                             int rsrc AU = (op[3] >> 4) & 0x0f;
 779 #line 559 "rx-decode.opc"
 780                             int rdst AU = op[3] & 0x0f;
 781                             if (trace)
 782                               {
 783                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 784                                        "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst     sbb     %1%S1, %0 */",
 785                                        op[0], op[1], op[2], op[3]);
 786                                 printf ("  mx = 0x%x,", mx);
 787                                 printf ("  sp = 0x%x,", sp);
 788                                 printf ("  rsrc = 0x%x,", rsrc);
 789                                 printf ("  rdst = 0x%x\n", rdst);
 790                               }
 791                             SYNTAX("sbb %1%S1, %0");
 792 #line 559 "rx-decode.opc"
 793                             ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
 794
 795                           /*----------------------------------------------------------------------*/
 796                           /* ABS                                                                        */
 797
 798                           }
 799                         break;
 800                     }
 801                   break;
 802                 case 0x04:
 803                     GETBYTE ();
 804                     switch (op[3] & 0x00)
 805                     {
 806                       case 0x00:
 807                         op_semantics_8:
 808                           {
 809                             /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max     %1%S1, %0 */
 810 #line 598 "rx-decode.opc"
 811                             int mx AU = (op[1] >> 6) & 0x03;
 812 #line 598 "rx-decode.opc"
 813                             int ss AU = op[1] & 0x03;
 814 #line 598 "rx-decode.opc"
 815                             int rsrc AU = (op[3] >> 4) & 0x0f;
 816 #line 598 "rx-decode.opc"
 817                             int rdst AU = op[3] & 0x0f;
 818                             if (trace)
 819                               {
 820                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 821                                        "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst     max     %1%S1, %0 */",
 822                                        op[0], op[1], op[2], op[3]);
 823                                 printf ("  mx = 0x%x,", mx);
 824                                 printf ("  ss = 0x%x,", ss);
 825                                 printf ("  rsrc = 0x%x,", rsrc);
 826                                 printf ("  rdst = 0x%x\n", rdst);
 827                               }
 828                             SYNTAX("max %1%S1, %0");
 829 #line 598 "rx-decode.opc"
 830                             ID(max); SPm(ss, rsrc, mx); DR(rdst);
 831
 832                           /*----------------------------------------------------------------------*/
 833                           /* MIN                                                                        */
 834
 835                           }
 836                         break;
 837                     }
 838                   break;
 839                 case 0x05:
 840                     GETBYTE ();
 841                     switch (op[3] & 0x00)
 842                     {
 843                       case 0x00:
 844                         op_semantics_9:
 845                           {
 846                             /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min     %1%S1, %0 */
 847 #line 610 "rx-decode.opc"
 848                             int mx AU = (op[1] >> 6) & 0x03;
 849 #line 610 "rx-decode.opc"
 850                             int ss AU = op[1] & 0x03;
 851 #line 610 "rx-decode.opc"
 852                             int rsrc AU = (op[3] >> 4) & 0x0f;
 853 #line 610 "rx-decode.opc"
 854                             int rdst AU = op[3] & 0x0f;
 855                             if (trace)
 856                               {
 857                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 858                                        "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst     min     %1%S1, %0 */",
 859                                        op[0], op[1], op[2], op[3]);
 860                                 printf ("  mx = 0x%x,", mx);
 861                                 printf ("  ss = 0x%x,", ss);
 862                                 printf ("  rsrc = 0x%x,", rsrc);
 863                                 printf ("  rdst = 0x%x\n", rdst);
 864                               }
 865                             SYNTAX("min %1%S1, %0");
 866 #line 610 "rx-decode.opc"
 867                             ID(min); SPm(ss, rsrc, mx); DR(rdst);
 868
 869                           /*----------------------------------------------------------------------*/
 870                           /* MUL                                                                        */
 871
 872                           }
 873                         break;
 874                     }
 875                   break;
 876                 case 0x06:
 877                     GETBYTE ();
 878                     switch (op[3] & 0x00)
 879                     {
 880                       case 0x00:
 881                         op_semantics_10:
 882                           {
 883                             /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul    %1%S1, %0 */
 884 #line 668 "rx-decode.opc"
 885                             int mx AU = (op[1] >> 6) & 0x03;
 886 #line 668 "rx-decode.opc"
 887                             int ss AU = op[1] & 0x03;
 888 #line 668 "rx-decode.opc"
 889                             int rsrc AU = (op[3] >> 4) & 0x0f;
 890 #line 668 "rx-decode.opc"
 891                             int rdst AU = op[3] & 0x0f;
 892                             if (trace)
 893                               {
 894                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 895                                        "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst     emul    %1%S1, %0 */",
 896                                        op[0], op[1], op[2], op[3]);
 897                                 printf ("  mx = 0x%x,", mx);
 898                                 printf ("  ss = 0x%x,", ss);
 899                                 printf ("  rsrc = 0x%x,", rsrc);
 900                                 printf ("  rdst = 0x%x\n", rdst);
 901                               }
 902                             SYNTAX("emul        %1%S1, %0");
 903 #line 668 "rx-decode.opc"
 904                             ID(emul); SPm(ss, rsrc, mx); DR(rdst);
 905
 906                           /*----------------------------------------------------------------------*/
 907                           /* EMULU                                                                      */
 908
 909                           }
 910                         break;
 911                     }
 912                   break;
 913                 case 0x07:
 914                     GETBYTE ();
 915                     switch (op[3] & 0x00)
 916                     {
 917                       case 0x00:
 918                         op_semantics_11:
 919                           {
 920                             /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu   %1%S1, %0 */
 921 #line 680 "rx-decode.opc"
 922                             int mx AU = (op[1] >> 6) & 0x03;
 923 #line 680 "rx-decode.opc"
 924                             int ss AU = op[1] & 0x03;
 925 #line 680 "rx-decode.opc"
 926                             int rsrc AU = (op[3] >> 4) & 0x0f;
 927 #line 680 "rx-decode.opc"
 928                             int rdst AU = op[3] & 0x0f;
 929                             if (trace)
 930                               {
 931                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 932                                        "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst     emulu   %1%S1, %0 */",
 933                                        op[0], op[1], op[2], op[3]);
 934                                 printf ("  mx = 0x%x,", mx);
 935                                 printf ("  ss = 0x%x,", ss);
 936                                 printf ("  rsrc = 0x%x,", rsrc);
 937                                 printf ("  rdst = 0x%x\n", rdst);
 938                               }
 939                             SYNTAX("emulu       %1%S1, %0");
 940 #line 680 "rx-decode.opc"
 941                             ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
 942
 943                           /*----------------------------------------------------------------------*/
 944                           /* DIV                                                                        */
 945
 946                           }
 947                         break;
 948                     }
 949                   break;
 950                 case 0x08:
 951                     GETBYTE ();
 952                     switch (op[3] & 0x00)
 953                     {
 954                       case 0x00:
 955                         op_semantics_12:
 956                           {
 957                             /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div     %1%S1, %0 */
 958 #line 692 "rx-decode.opc"
 959                             int mx AU = (op[1] >> 6) & 0x03;
 960 #line 692 "rx-decode.opc"
 961                             int ss AU = op[1] & 0x03;
 962 #line 692 "rx-decode.opc"
 963                             int rsrc AU = (op[3] >> 4) & 0x0f;
 964 #line 692 "rx-decode.opc"
 965                             int rdst AU = op[3] & 0x0f;
 966                             if (trace)
 967                               {
 968                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 969                                        "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst     div     %1%S1, %0 */",
 970                                        op[0], op[1], op[2], op[3]);
 971                                 printf ("  mx = 0x%x,", mx);
 972                                 printf ("  ss = 0x%x,", ss);
 973                                 printf ("  rsrc = 0x%x,", rsrc);
 974                                 printf ("  rdst = 0x%x\n", rdst);
 975                               }
 976                             SYNTAX("div %1%S1, %0");
 977 #line 692 "rx-decode.opc"
 978                             ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
 979
 980                           /*----------------------------------------------------------------------*/
 981                           /* DIVU                                                                       */
 982
 983                           }
 984                         break;
 985                     }
 986                   break;
 987                 case 0x09:
 988                     GETBYTE ();
 989                     switch (op[3] & 0x00)
 990                     {
 991                       case 0x00:
 992                         op_semantics_13:
 993                           {
 994                             /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu    %1%S1, %0 */
 995 #line 704 "rx-decode.opc"
 996                             int mx AU = (op[1] >> 6) & 0x03;
 997 #line 704 "rx-decode.opc"
 998                             int ss AU = op[1] & 0x03;
 999 #line 704 "rx-decode.opc"
1000                             int rsrc AU = (op[3] >> 4) & 0x0f;
1001 #line 704 "rx-decode.opc"
1002                             int rdst AU = op[3] & 0x0f;
1003                             if (trace)
1004                               {
1005                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1006                                        "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst     divu    %1%S1, %0 */",
1007                                        op[0], op[1], op[2], op[3]);
1008                                 printf ("  mx = 0x%x,", mx);
1009                                 printf ("  ss = 0x%x,", ss);
1010                                 printf ("  rsrc = 0x%x,", rsrc);
1011                                 printf ("  rdst = 0x%x\n", rdst);
1012                               }
1013                             SYNTAX("divu        %1%S1, %0");
1014 #line 704 "rx-decode.opc"
1015                             ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1016
1017                           /*----------------------------------------------------------------------*/
1018                           /* SHIFT                                                              */
1019
1020                           }
1021                         break;
1022                     }
1023                   break;
1024                 case 0x0c:
1025                     GETBYTE ();
1026                     switch (op[3] & 0x00)
1027                     {
1028                       case 0x00:
1029                         op_semantics_14:
1030                           {
1031                             /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst     %1%S1, %2 */
1032 #line 477 "rx-decode.opc"
1033                             int mx AU = (op[1] >> 6) & 0x03;
1034 #line 477 "rx-decode.opc"
1035                             int ss AU = op[1] & 0x03;
1036 #line 477 "rx-decode.opc"
1037                             int rsrc AU = (op[3] >> 4) & 0x0f;
1038 #line 477 "rx-decode.opc"
1039                             int rdst AU = op[3] & 0x0f;
1040                             if (trace)
1041                               {
1042                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1043                                        "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst     tst     %1%S1, %2 */",
1044                                        op[0], op[1], op[2], op[3]);
1045                                 printf ("  mx = 0x%x,", mx);
1046                                 printf ("  ss = 0x%x,", ss);
1047                                 printf ("  rsrc = 0x%x,", rsrc);
1048                                 printf ("  rdst = 0x%x\n", rdst);
1049                               }
1050                             SYNTAX("tst %1%S1, %2");
1051 #line 477 "rx-decode.opc"
1052                             ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1053
1054                           /*----------------------------------------------------------------------*/
1055                           /* NEG                                                                        */
1056
1057                           }
1058                         break;
1059                     }
1060                   break;
1061                 case 0x0d:
1062                     GETBYTE ();
1063                     switch (op[3] & 0x00)
1064                     {
1065                       case 0x00:
1066                         op_semantics_15:
1067                           {
1068                             /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor     %1%S1, %0 */
1069 #line 456 "rx-decode.opc"
1070                             int mx AU = (op[1] >> 6) & 0x03;
1071 #line 456 "rx-decode.opc"
1072                             int ss AU = op[1] & 0x03;
1073 #line 456 "rx-decode.opc"
1074                             int rsrc AU = (op[3] >> 4) & 0x0f;
1075 #line 456 "rx-decode.opc"
1076                             int rdst AU = op[3] & 0x0f;
1077                             if (trace)
1078                               {
1079                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1080                                        "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst     xor     %1%S1, %0 */",
1081                                        op[0], op[1], op[2], op[3]);
1082                                 printf ("  mx = 0x%x,", mx);
1083                                 printf ("  ss = 0x%x,", ss);
1084                                 printf ("  rsrc = 0x%x,", rsrc);
1085                                 printf ("  rdst = 0x%x\n", rdst);
1086                               }
1087                             SYNTAX("xor %1%S1, %0");
1088 #line 456 "rx-decode.opc"
1089                             ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1090
1091                           /*----------------------------------------------------------------------*/
1092                           /* NOT                                                                        */
1093
1094                           }
1095                         break;
1096                     }
1097                   break;
1098                 case 0x10:
1099                     GETBYTE ();
1100                     switch (op[3] & 0x00)
1101                     {
1102                       case 0x00:
1103                         op_semantics_16:
1104                           {
1105                             /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg    %1%S1, %0 */
1106 #line 390 "rx-decode.opc"
1107                             int mx AU = (op[1] >> 6) & 0x03;
1108 #line 390 "rx-decode.opc"
1109                             int ss AU = op[1] & 0x03;
1110 #line 390 "rx-decode.opc"
1111                             int rsrc AU = (op[3] >> 4) & 0x0f;
1112 #line 390 "rx-decode.opc"
1113                             int rdst AU = op[3] & 0x0f;
1114                             if (trace)
1115                               {
1116                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1117                                        "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst     xchg    %1%S1, %0 */",
1118                                        op[0], op[1], op[2], op[3]);
1119                                 printf ("  mx = 0x%x,", mx);
1120                                 printf ("  ss = 0x%x,", ss);
1121                                 printf ("  rsrc = 0x%x,", rsrc);
1122                                 printf ("  rdst = 0x%x\n", rdst);
1123                               }
1124                             SYNTAX("xchg        %1%S1, %0");
1125 #line 390 "rx-decode.opc"
1126                             ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1127
1128                           /*----------------------------------------------------------------------*/
1129                           /* STZ/STNZ                                                           */
1130
1131                           }
1132                         break;
1133                     }
1134                   break;
1135                 case 0x11:
1136                     GETBYTE ();
1137                     switch (op[3] & 0x00)
1138                     {
1139                       case 0x00:
1140                         op_semantics_17:
1141                           {
1142                             /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof    %1%S1, %0 */
1143 #line 933 "rx-decode.opc"
1144                             int mx AU = (op[1] >> 6) & 0x03;
1145 #line 933 "rx-decode.opc"
1146                             int sd AU = op[1] & 0x03;
1147 #line 933 "rx-decode.opc"
1148                             int rsrc AU = (op[3] >> 4) & 0x0f;
1149 #line 933 "rx-decode.opc"
1150                             int rdst AU = op[3] & 0x0f;
1151                             if (trace)
1152                               {
1153                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1154                                        "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst     itof    %1%S1, %0 */",
1155                                        op[0], op[1], op[2], op[3]);
1156                                 printf ("  mx = 0x%x,", mx);
1157                                 printf ("  sd = 0x%x,", sd);
1158                                 printf ("  rsrc = 0x%x,", rsrc);
1159                                 printf ("  rdst = 0x%x\n", rdst);
1160                               }
1161                             SYNTAX("itof        %1%S1, %0");
1162 #line 933 "rx-decode.opc"
1163                             ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1164
1165                           /*----------------------------------------------------------------------*/
1166                           /* BIT OPS                                                            */
1167
1168                           }
1169                         break;
1170                     }
1171                   break;
1172                 case 0x15:
1173                     GETBYTE ();
1174                     switch (op[3] & 0x00)
1175                     {
1176                       case 0x00:
1177                         op_semantics_18:
1178                           {
1179                             /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof    %1%S1, %0 */
1180 #line 1119 "rx-decode.opc"
1181                             int mx AU = (op[1] >> 6) & 0x03;
1182 #line 1119 "rx-decode.opc"
1183                             int sd AU = op[1] & 0x03;
1184 #line 1119 "rx-decode.opc"
1185                             int rsrc AU = (op[3] >> 4) & 0x0f;
1186 #line 1119 "rx-decode.opc"
1187                             int rdst AU = op[3] & 0x0f;
1188                             if (trace)
1189                               {
1190                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1191                                        "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst     utof    %1%S1, %0 */",
1192                                        op[0], op[1], op[2], op[3]);
1193                                 printf ("  mx = 0x%x,", mx);
1194                                 printf ("  sd = 0x%x,", sd);
1195                                 printf ("  rsrc = 0x%x,", rsrc);
1196                                 printf ("  rdst = 0x%x\n", rdst);
1197                               }
1198                             SYNTAX("utof        %1%S1, %0");
1199 #line 1119 "rx-decode.opc"
1200                             ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1201
1202                           }
1203                         break;
1204                     }
1205                   break;
1206                 default: UNSUPPORTED(); break;
1207               }
1208             break;
1209           case 0x21:
1210               GETBYTE ();
1211               switch (op[2] & 0xff)
1212               {
1213                 case 0x00:
1214                     GETBYTE ();
1215                     switch (op[3] & 0x00)
1216                     {
1217                       case 0x00:
1218                         goto op_semantics_7;
1219                         break;
1220                     }
1221                   break;
1222                 case 0x04:
1223                     GETBYTE ();
1224                     switch (op[3] & 0x00)
1225                     {
1226                       case 0x00:
1227                         goto op_semantics_8;
1228                         break;
1229                     }
1230                   break;
1231                 case 0x05:
1232                     GETBYTE ();
1233                     switch (op[3] & 0x00)
1234                     {
1235                       case 0x00:
1236                         goto op_semantics_9;
1237                         break;
1238                     }
1239                   break;
1240                 case 0x06:
1241                     GETBYTE ();
1242                     switch (op[3] & 0x00)
1243                     {
1244                       case 0x00:
1245                         goto op_semantics_10;
1246                         break;
1247                     }
1248                   break;
1249                 case 0x07:
1250                     GETBYTE ();
1251                     switch (op[3] & 0x00)
1252                     {
1253                       case 0x00:
1254                         goto op_semantics_11;
1255                         break;
1256                     }
1257                   break;
1258                 case 0x08:
1259                     GETBYTE ();
1260                     switch (op[3] & 0x00)
1261                     {
1262                       case 0x00:
1263                         goto op_semantics_12;
1264                         break;
1265                     }
1266                   break;
1267                 case 0x09:
1268                     GETBYTE ();
1269                     switch (op[3] & 0x00)
1270                     {
1271                       case 0x00:
1272                         goto op_semantics_13;
1273                         break;
1274                     }
1275                   break;
1276                 case 0x0c:
1277                     GETBYTE ();
1278                     switch (op[3] & 0x00)
1279                     {
1280                       case 0x00:
1281                         goto op_semantics_14;
1282                         break;
1283                     }
1284                   break;
1285                 case 0x0d:
1286                     GETBYTE ();
1287                     switch (op[3] & 0x00)
1288                     {
1289                       case 0x00:
1290                         goto op_semantics_15;
1291                         break;
1292                     }
1293                   break;
1294                 case 0x10:
1295                     GETBYTE ();
1296                     switch (op[3] & 0x00)
1297                     {
1298                       case 0x00:
1299                         goto op_semantics_16;
1300                         break;
1301                     }
1302                   break;
1303                 case 0x11:
1304                     GETBYTE ();
1305                     switch (op[3] & 0x00)
1306                     {
1307                       case 0x00:
1308                         goto op_semantics_17;
1309                         break;
1310                     }
1311                   break;
1312                 case 0x15:
1313                     GETBYTE ();
1314                     switch (op[3] & 0x00)
1315                     {
1316                       case 0x00:
1317                         goto op_semantics_18;
1318                         break;
1319                     }
1320                   break;
1321                 default: UNSUPPORTED(); break;
1322               }
1323             break;
1324           case 0x22:
1325               GETBYTE ();
1326               switch (op[2] & 0xff)
1327               {
1328                 case 0x00:
1329                     GETBYTE ();
1330                     switch (op[3] & 0x00)
1331                     {
1332                       case 0x00:
1333                         goto op_semantics_7;
1334                         break;
1335                     }
1336                   break;
1337                 case 0x04:
1338                     GETBYTE ();
1339                     switch (op[3] & 0x00)
1340                     {
1341                       case 0x00:
1342                         goto op_semantics_8;
1343                         break;
1344                     }
1345                   break;
1346                 case 0x05:
1347                     GETBYTE ();
1348                     switch (op[3] & 0x00)
1349                     {
1350                       case 0x00:
1351                         goto op_semantics_9;
1352                         break;
1353                     }
1354                   break;
1355                 case 0x06:
1356                     GETBYTE ();
1357                     switch (op[3] & 0x00)
1358                     {
1359                       case 0x00:
1360                         goto op_semantics_10;
1361                         break;
1362                     }
1363                   break;
1364                 case 0x07:
1365                     GETBYTE ();
1366                     switch (op[3] & 0x00)
1367                     {
1368                       case 0x00:
1369                         goto op_semantics_11;
1370                         break;
1371                     }
1372                   break;
1373                 case 0x08:
1374                     GETBYTE ();
1375                     switch (op[3] & 0x00)
1376                     {
1377                       case 0x00:
1378                         goto op_semantics_12;
1379                         break;
1380                     }
1381                   break;
1382                 case 0x09:
1383                     GETBYTE ();
1384                     switch (op[3] & 0x00)
1385                     {
1386                       case 0x00:
1387                         goto op_semantics_13;
1388                         break;
1389                     }
1390                   break;
1391                 case 0x0c:
1392                     GETBYTE ();
1393                     switch (op[3] & 0x00)
1394                     {
1395                       case 0x00:
1396                         goto op_semantics_14;
1397                         break;
1398                     }
1399                   break;
1400                 case 0x0d:
1401                     GETBYTE ();
1402                     switch (op[3] & 0x00)
1403                     {
1404                       case 0x00:
1405                         goto op_semantics_15;
1406                         break;
1407                     }
1408                   break;
1409                 case 0x10:
1410                     GETBYTE ();
1411                     switch (op[3] & 0x00)
1412                     {
1413                       case 0x00:
1414                         goto op_semantics_16;
1415                         break;
1416                     }
1417                   break;
1418                 case 0x11:
1419                     GETBYTE ();
1420                     switch (op[3] & 0x00)
1421                     {
1422                       case 0x00:
1423                         goto op_semantics_17;
1424                         break;
1425                     }
1426                   break;
1427                 case 0x15:
1428                     GETBYTE ();
1429                     switch (op[3] & 0x00)
1430                     {
1431                       case 0x00:
1432                         goto op_semantics_18;
1433                         break;
1434                     }
1435                   break;
1436                 default: UNSUPPORTED(); break;
1437               }
1438             break;
1439           case 0x23:
1440               GETBYTE ();
1441               switch (op[2] & 0xff)
1442               {
1443                 case 0x00:
1444                     GETBYTE ();
1445                     switch (op[3] & 0x00)
1446                     {
1447                       case 0x00:
1448                         goto op_semantics_7;
1449                         break;
1450                     }
1451                   break;
1452                 case 0x04:
1453                     GETBYTE ();
1454                     switch (op[3] & 0x00)
1455                     {
1456                       case 0x00:
1457                         goto op_semantics_8;
1458                         break;
1459                     }
1460                   break;
1461                 case 0x05:
1462                     GETBYTE ();
1463                     switch (op[3] & 0x00)
1464                     {
1465                       case 0x00:
1466                         goto op_semantics_9;
1467                         break;
1468                     }
1469                   break;
1470                 case 0x06:
1471                     GETBYTE ();
1472                     switch (op[3] & 0x00)
1473                     {
1474                       case 0x00:
1475                         goto op_semantics_10;
1476                         break;
1477                     }
1478                   break;
1479                 case 0x07:
1480                     GETBYTE ();
1481                     switch (op[3] & 0x00)
1482                     {
1483                       case 0x00:
1484                         goto op_semantics_11;
1485                         break;
1486                     }
1487                   break;
1488                 case 0x08:
1489                     GETBYTE ();
1490                     switch (op[3] & 0x00)
1491                     {
1492                       case 0x00:
1493                         goto op_semantics_12;
1494                         break;
1495                     }
1496                   break;
1497                 case 0x09:
1498                     GETBYTE ();
1499                     switch (op[3] & 0x00)
1500                     {
1501                       case 0x00:
1502                         goto op_semantics_13;
1503                         break;
1504                     }
1505                   break;
1506                 case 0x0c:
1507                     GETBYTE ();
1508                     switch (op[3] & 0x00)
1509                     {
1510                       case 0x00:
1511                         goto op_semantics_14;
1512                         break;
1513                     }
1514                   break;
1515                 case 0x0d:
1516                     GETBYTE ();
1517                     switch (op[3] & 0x00)
1518                     {
1519                       case 0x00:
1520                         goto op_semantics_15;
1521                         break;
1522                     }
1523                   break;
1524                 case 0x10:
1525                     GETBYTE ();
1526                     switch (op[3] & 0x00)
1527                     {
1528                       case 0x00:
1529                         goto op_semantics_16;
1530                         break;
1531                     }
1532                   break;
1533                 case 0x11:
1534                     GETBYTE ();
1535                     switch (op[3] & 0x00)
1536                     {
1537                       case 0x00:
1538                         goto op_semantics_17;
1539                         break;
1540                     }
1541                   break;
1542                 case 0x15:
1543                     GETBYTE ();
1544                     switch (op[3] & 0x00)
1545                     {
1546                       case 0x00:
1547                         goto op_semantics_18;
1548                         break;
1549                     }
1550                   break;
1551                 default: UNSUPPORTED(); break;
1552               }
1553             break;
1554           case 0x40:
1555               GETBYTE ();
1556               switch (op[2] & 0x00)
1557               {
1558                 case 0x00:
1559                   goto op_semantics_1;
1560                   break;
1561               }
1562             break;
1563           case 0x41:
1564               GETBYTE ();
1565               switch (op[2] & 0x00)
1566               {
1567                 case 0x00:
1568                   goto op_semantics_1;
1569                   break;
1570               }
1571             break;
1572           case 0x42:
1573               GETBYTE ();
1574               switch (op[2] & 0x00)
1575               {
1576                 case 0x00:
1577                   goto op_semantics_1;
1578                   break;
1579               }
1580             break;
1581           case 0x43:
1582               GETBYTE ();
1583               switch (op[2] & 0x00)
1584               {
1585                 case 0x00:
1586                   goto op_semantics_1;
1587                   break;
1588               }
1589             break;
1590           case 0x44:
1591               GETBYTE ();
1592               switch (op[2] & 0x00)
1593               {
1594                 case 0x00:
1595                   goto op_semantics_2;
1596                   break;
1597               }
1598             break;
1599           case 0x45:
1600               GETBYTE ();
1601               switch (op[2] & 0x00)
1602               {
1603                 case 0x00:
1604                   goto op_semantics_2;
1605                   break;
1606               }
1607             break;
1608           case 0x46:
1609               GETBYTE ();
1610               switch (op[2] & 0x00)
1611               {
1612                 case 0x00:
1613                   goto op_semantics_2;
1614                   break;
1615               }
1616             break;
1617           case 0x47:
1618               GETBYTE ();
1619               switch (op[2] & 0x00)
1620               {
1621                 case 0x00:
1622                   goto op_semantics_2;
1623                   break;
1624               }
1625             break;
1626           case 0x48:
1627               GETBYTE ();
1628               switch (op[2] & 0x00)
1629               {
1630                 case 0x00:
1631                   goto op_semantics_3;
1632                   break;
1633               }
1634             break;
1635           case 0x49:
1636               GETBYTE ();
1637               switch (op[2] & 0x00)
1638               {
1639                 case 0x00:
1640                   goto op_semantics_3;
1641                   break;
1642               }
1643             break;
1644           case 0x4a:
1645               GETBYTE ();
1646               switch (op[2] & 0x00)
1647               {
1648                 case 0x00:
1649                   goto op_semantics_3;
1650                   break;
1651               }
1652             break;
1653           case 0x4b:
1654               GETBYTE ();
1655               switch (op[2] & 0x00)
1656               {
1657                 case 0x00:
1658                   goto op_semantics_3;
1659                   break;
1660               }
1661             break;
1662           case 0x4c:
1663               GETBYTE ();
1664               switch (op[2] & 0x00)
1665               {
1666                 case 0x00:
1667                   goto op_semantics_4;
1668                   break;
1669               }
1670             break;
1671           case 0x4d:
1672               GETBYTE ();
1673               switch (op[2] & 0x00)
1674               {
1675                 case 0x00:
1676                   goto op_semantics_4;
1677                   break;
1678               }
1679             break;
1680           case 0x4e:
1681               GETBYTE ();
1682               switch (op[2] & 0x00)
1683               {
1684                 case 0x00:
1685                   goto op_semantics_4;
1686                   break;
1687               }
1688             break;
1689           case 0x4f:
1690               GETBYTE ();
1691               switch (op[2] & 0x00)
1692               {
1693                 case 0x00:
1694                   goto op_semantics_4;
1695                   break;
1696               }
1697             break;
1698           case 0x50:
1699               GETBYTE ();
1700               switch (op[2] & 0x00)
1701               {
1702                 case 0x00:
1703                   goto op_semantics_5;
1704                   break;
1705               }
1706             break;
1707           case 0x51:
1708               GETBYTE ();
1709               switch (op[2] & 0x00)
1710               {
1711                 case 0x00:
1712                   goto op_semantics_5;
1713                   break;
1714               }
1715             break;
1716           case 0x52:
1717               GETBYTE ();
1718               switch (op[2] & 0x00)
1719               {
1720                 case 0x00:
1721                   goto op_semantics_5;
1722                   break;
1723               }
1724             break;
1725           case 0x53:
1726               GETBYTE ();
1727               switch (op[2] & 0x00)
1728               {
1729                 case 0x00:
1730                   goto op_semantics_5;
1731                   break;
1732               }
1733             break;
1734           case 0x54:
1735               GETBYTE ();
1736               switch (op[2] & 0x00)
1737               {
1738                 case 0x00:
1739                   goto op_semantics_6;
1740                   break;
1741               }
1742             break;
1743           case 0x55:
1744               GETBYTE ();
1745               switch (op[2] & 0x00)
1746               {
1747                 case 0x00:
1748                   goto op_semantics_6;
1749                   break;
1750               }
1751             break;
1752           case 0x56:
1753               GETBYTE ();
1754               switch (op[2] & 0x00)
1755               {
1756                 case 0x00:
1757                   goto op_semantics_6;
1758                   break;
1759               }
1760             break;
1761           case 0x57:
1762               GETBYTE ();
1763               switch (op[2] & 0x00)
1764               {
1765                 case 0x00:
1766                   goto op_semantics_6;
1767                   break;
1768               }
1769             break;
1770           case 0x60:
1771               GETBYTE ();
1772               switch (op[2] & 0xff)
1773               {
1774                 case 0x00:
1775                     GETBYTE ();
1776                     switch (op[3] & 0x00)
1777                     {
1778                       case 0x00:
1779                         goto op_semantics_7;
1780                         break;
1781                     }
1782                   break;
1783                 case 0x04:
1784                     GETBYTE ();
1785                     switch (op[3] & 0x00)
1786                     {
1787                       case 0x00:
1788                         goto op_semantics_8;
1789                         break;
1790                     }
1791                   break;
1792                 case 0x05:
1793                     GETBYTE ();
1794                     switch (op[3] & 0x00)
1795                     {
1796                       case 0x00:
1797                         goto op_semantics_9;
1798                         break;
1799                     }
1800                   break;
1801                 case 0x06:
1802                     GETBYTE ();
1803                     switch (op[3] & 0x00)
1804                     {
1805                       case 0x00:
1806                         goto op_semantics_10;
1807                         break;
1808                     }
1809                   break;
1810                 case 0x07:
1811                     GETBYTE ();
1812                     switch (op[3] & 0x00)
1813                     {
1814                       case 0x00:
1815                         goto op_semantics_11;
1816                         break;
1817                     }
1818                   break;
1819                 case 0x08:
1820                     GETBYTE ();
1821                     switch (op[3] & 0x00)
1822                     {
1823                       case 0x00:
1824                         goto op_semantics_12;
1825                         break;
1826                     }
1827                   break;
1828                 case 0x09:
1829                     GETBYTE ();
1830                     switch (op[3] & 0x00)
1831                     {
1832                       case 0x00:
1833                         goto op_semantics_13;
1834                         break;
1835                     }
1836                   break;
1837                 case 0x0c:
1838                     GETBYTE ();
1839                     switch (op[3] & 0x00)
1840                     {
1841                       case 0x00:
1842                         goto op_semantics_14;
1843                         break;
1844                     }
1845                   break;
1846                 case 0x0d:
1847                     GETBYTE ();
1848                     switch (op[3] & 0x00)
1849                     {
1850                       case 0x00:
1851                         goto op_semantics_15;
1852                         break;
1853                     }
1854                   break;
1855                 case 0x10:
1856                     GETBYTE ();
1857                     switch (op[3] & 0x00)
1858                     {
1859                       case 0x00:
1860                         goto op_semantics_16;
1861                         break;
1862                     }
1863                   break;
1864                 case 0x11:
1865                     GETBYTE ();
1866                     switch (op[3] & 0x00)
1867                     {
1868                       case 0x00:
1869                         goto op_semantics_17;
1870                         break;
1871                     }
1872                   break;
1873                 case 0x15:
1874                     GETBYTE ();
1875                     switch (op[3] & 0x00)
1876                     {
1877                       case 0x00:
1878                         goto op_semantics_18;
1879                         break;
1880                     }
1881                   break;
1882                 default: UNSUPPORTED(); break;
1883               }
1884             break;
1885           case 0x61:
1886               GETBYTE ();
1887               switch (op[2] & 0xff)
1888               {
1889                 case 0x00:
1890                     GETBYTE ();
1891                     switch (op[3] & 0x00)
1892                     {
1893                       case 0x00:
1894                         goto op_semantics_7;
1895                         break;
1896                     }
1897                   break;
1898                 case 0x04:
1899                     GETBYTE ();
1900                     switch (op[3] & 0x00)
1901                     {
1902                       case 0x00:
1903                         goto op_semantics_8;
1904                         break;
1905                     }
1906                   break;
1907                 case 0x05:
1908                     GETBYTE ();
1909                     switch (op[3] & 0x00)
1910                     {
1911                       case 0x00:
1912                         goto op_semantics_9;
1913                         break;
1914                     }
1915                   break;
1916                 case 0x06:
1917                     GETBYTE ();
1918                     switch (op[3] & 0x00)
1919                     {
1920                       case 0x00:
1921                         goto op_semantics_10;
1922                         break;
1923                     }
1924                   break;
1925                 case 0x07:
1926                     GETBYTE ();
1927                     switch (op[3] & 0x00)
1928                     {
1929                       case 0x00:
1930                         goto op_semantics_11;
1931                         break;
1932                     }
1933                   break;
1934                 case 0x08:
1935                     GETBYTE ();
1936                     switch (op[3] & 0x00)
1937                     {
1938                       case 0x00:
1939                         goto op_semantics_12;
1940                         break;
1941                     }
1942                   break;
1943                 case 0x09:
1944                     GETBYTE ();
1945                     switch (op[3] & 0x00)
1946                     {
1947                       case 0x00:
1948                         goto op_semantics_13;
1949                         break;
1950                     }
1951                   break;
1952                 case 0x0c:
1953                     GETBYTE ();
1954                     switch (op[3] & 0x00)
1955                     {
1956                       case 0x00:
1957                         goto op_semantics_14;
1958                         break;
1959                     }
1960                   break;
1961                 case 0x0d:
1962                     GETBYTE ();
1963                     switch (op[3] & 0x00)
1964                     {
1965                       case 0x00:
1966                         goto op_semantics_15;
1967                         break;
1968                     }
1969                   break;
1970                 case 0x10:
1971                     GETBYTE ();
1972                     switch (op[3] & 0x00)
1973                     {
1974                       case 0x00:
1975                         goto op_semantics_16;
1976                         break;
1977                     }
1978                   break;
1979                 case 0x11:
1980                     GETBYTE ();
1981                     switch (op[3] & 0x00)
1982                     {
1983                       case 0x00:
1984                         goto op_semantics_17;
1985                         break;
1986                     }
1987                   break;
1988                 case 0x15:
1989                     GETBYTE ();
1990                     switch (op[3] & 0x00)
1991                     {
1992                       case 0x00:
1993                         goto op_semantics_18;
1994                         break;
1995                     }
1996                   break;
1997                 default: UNSUPPORTED(); break;
1998               }
1999             break;
2000           case 0x62:
2001               GETBYTE ();
2002               switch (op[2] & 0xff)
2003               {
2004                 case 0x00:
2005                     GETBYTE ();
2006                     switch (op[3] & 0x00)
2007                     {
2008                       case 0x00:
2009                         goto op_semantics_7;
2010                         break;
2011                     }
2012                   break;
2013                 case 0x04:
2014                     GETBYTE ();
2015                     switch (op[3] & 0x00)
2016                     {
2017                       case 0x00:
2018                         goto op_semantics_8;
2019                         break;
2020                     }
2021                   break;
2022                 case 0x05:
2023                     GETBYTE ();
2024                     switch (op[3] & 0x00)
2025                     {
2026                       case 0x00:
2027                         goto op_semantics_9;
2028                         break;
2029                     }
2030                   break;
2031                 case 0x06:
2032                     GETBYTE ();
2033                     switch (op[3] & 0x00)
2034                     {
2035                       case 0x00:
2036                         goto op_semantics_10;
2037                         break;
2038                     }
2039                   break;
2040                 case 0x07:
2041                     GETBYTE ();
2042                     switch (op[3] & 0x00)
2043                     {
2044                       case 0x00:
2045                         goto op_semantics_11;
2046                         break;
2047                     }
2048                   break;
2049                 case 0x08:
2050                     GETBYTE ();
2051                     switch (op[3] & 0x00)
2052                     {
2053                       case 0x00:
2054                         goto op_semantics_12;
2055                         break;
2056                     }
2057                   break;
2058                 case 0x09:
2059                     GETBYTE ();
2060                     switch (op[3] & 0x00)
2061                     {
2062                       case 0x00:
2063                         goto op_semantics_13;
2064                         break;
2065                     }
2066                   break;
2067                 case 0x0c:
2068                     GETBYTE ();
2069                     switch (op[3] & 0x00)
2070                     {
2071                       case 0x00:
2072                         goto op_semantics_14;
2073                         break;
2074                     }
2075                   break;
2076                 case 0x0d:
2077                     GETBYTE ();
2078                     switch (op[3] & 0x00)
2079                     {
2080                       case 0x00:
2081                         goto op_semantics_15;
2082                         break;
2083                     }
2084                   break;
2085                 case 0x10:
2086                     GETBYTE ();
2087                     switch (op[3] & 0x00)
2088                     {
2089                       case 0x00:
2090                         goto op_semantics_16;
2091                         break;
2092                     }
2093                   break;
2094                 case 0x11:
2095                     GETBYTE ();
2096                     switch (op[3] & 0x00)
2097                     {
2098                       case 0x00:
2099                         goto op_semantics_17;
2100                         break;
2101                     }
2102                   break;
2103                 case 0x15:
2104                     GETBYTE ();
2105                     switch (op[3] & 0x00)
2106                     {
2107                       case 0x00:
2108                         goto op_semantics_18;
2109                         break;
2110                     }
2111                   break;
2112                 default: UNSUPPORTED(); break;
2113               }
2114             break;
2115           case 0x63:
2116               GETBYTE ();
2117               switch (op[2] & 0xff)
2118               {
2119                 case 0x00:
2120                     GETBYTE ();
2121                     switch (op[3] & 0x00)
2122                     {
2123                       case 0x00:
2124                         goto op_semantics_7;
2125                         break;
2126                     }
2127                   break;
2128                 case 0x04:
2129                     GETBYTE ();
2130                     switch (op[3] & 0x00)
2131                     {
2132                       case 0x00:
2133                         goto op_semantics_8;
2134                         break;
2135                     }
2136                   break;
2137                 case 0x05:
2138                     GETBYTE ();
2139                     switch (op[3] & 0x00)
2140                     {
2141                       case 0x00:
2142                         goto op_semantics_9;
2143                         break;
2144                     }
2145                   break;
2146                 case 0x06:
2147                     GETBYTE ();
2148                     switch (op[3] & 0x00)
2149                     {
2150                       case 0x00:
2151                         goto op_semantics_10;
2152                         break;
2153                     }
2154                   break;
2155                 case 0x07:
2156                     GETBYTE ();
2157                     switch (op[3] & 0x00)
2158                     {
2159                       case 0x00:
2160                         goto op_semantics_11;
2161                         break;
2162                     }
2163                   break;
2164                 case 0x08:
2165                     GETBYTE ();
2166                     switch (op[3] & 0x00)
2167                     {
2168                       case 0x00:
2169                         goto op_semantics_12;
2170                         break;
2171                     }
2172                   break;
2173                 case 0x09:
2174                     GETBYTE ();
2175                     switch (op[3] & 0x00)
2176                     {
2177                       case 0x00:
2178                         goto op_semantics_13;
2179                         break;
2180                     }
2181                   break;
2182                 case 0x0c:
2183                     GETBYTE ();
2184                     switch (op[3] & 0x00)
2185                     {
2186                       case 0x00:
2187                         goto op_semantics_14;
2188                         break;
2189                     }
2190                   break;
2191                 case 0x0d:
2192                     GETBYTE ();
2193                     switch (op[3] & 0x00)
2194                     {
2195                       case 0x00:
2196                         goto op_semantics_15;
2197                         break;
2198                     }
2199                   break;
2200                 case 0x10:
2201                     GETBYTE ();
2202                     switch (op[3] & 0x00)
2203                     {
2204                       case 0x00:
2205                         goto op_semantics_16;
2206                         break;
2207                     }
2208                   break;
2209                 case 0x11:
2210                     GETBYTE ();
2211                     switch (op[3] & 0x00)
2212                     {
2213                       case 0x00:
2214                         goto op_semantics_17;
2215                         break;
2216                     }
2217                   break;
2218                 case 0x15:
2219                     GETBYTE ();
2220                     switch (op[3] & 0x00)
2221                     {
2222                       case 0x00:
2223                         goto op_semantics_18;
2224                         break;
2225                     }
2226                   break;
2227                 default: UNSUPPORTED(); break;
2228               }
2229             break;
2230           case 0x80:
2231               GETBYTE ();
2232               switch (op[2] & 0x00)
2233               {
2234                 case 0x00:
2235                   goto op_semantics_1;
2236                   break;
2237               }
2238             break;
2239           case 0x81:
2240               GETBYTE ();
2241               switch (op[2] & 0x00)
2242               {
2243                 case 0x00:
2244                   goto op_semantics_1;
2245                   break;
2246               }
2247             break;
2248           case 0x82:
2249               GETBYTE ();
2250               switch (op[2] & 0x00)
2251               {
2252                 case 0x00:
2253                   goto op_semantics_1;
2254                   break;
2255               }
2256             break;
2257           case 0x83:
2258               GETBYTE ();
2259               switch (op[2] & 0x00)
2260               {
2261                 case 0x00:
2262                   goto op_semantics_1;
2263                   break;
2264               }
2265             break;
2266           case 0x84:
2267               GETBYTE ();
2268               switch (op[2] & 0x00)
2269               {
2270                 case 0x00:
2271                   goto op_semantics_2;
2272                   break;
2273               }
2274             break;
2275           case 0x85:
2276               GETBYTE ();
2277               switch (op[2] & 0x00)
2278               {
2279                 case 0x00:
2280                   goto op_semantics_2;
2281                   break;
2282               }
2283             break;
2284           case 0x86:
2285               GETBYTE ();
2286               switch (op[2] & 0x00)
2287               {
2288                 case 0x00:
2289                   goto op_semantics_2;
2290                   break;
2291               }
2292             break;
2293           case 0x87:
2294               GETBYTE ();
2295               switch (op[2] & 0x00)
2296               {
2297                 case 0x00:
2298                   goto op_semantics_2;
2299                   break;
2300               }
2301             break;
2302           case 0x88:
2303               GETBYTE ();
2304               switch (op[2] & 0x00)
2305               {
2306                 case 0x00:
2307                   goto op_semantics_3;
2308                   break;
2309               }
2310             break;
2311           case 0x89:
2312               GETBYTE ();
2313               switch (op[2] & 0x00)
2314               {
2315                 case 0x00:
2316                   goto op_semantics_3;
2317                   break;
2318               }
2319             break;
2320           case 0x8a:
2321               GETBYTE ();
2322               switch (op[2] & 0x00)
2323               {
2324                 case 0x00:
2325                   goto op_semantics_3;
2326                   break;
2327               }
2328             break;
2329           case 0x8b:
2330               GETBYTE ();
2331               switch (op[2] & 0x00)
2332               {
2333                 case 0x00:
2334                   goto op_semantics_3;
2335                   break;
2336               }
2337             break;
2338           case 0x8c:
2339               GETBYTE ();
2340               switch (op[2] & 0x00)
2341               {
2342                 case 0x00:
2343                   goto op_semantics_4;
2344                   break;
2345               }
2346             break;
2347           case 0x8d:
2348               GETBYTE ();
2349               switch (op[2] & 0x00)
2350               {
2351                 case 0x00:
2352                   goto op_semantics_4;
2353                   break;
2354               }
2355             break;
2356           case 0x8e:
2357               GETBYTE ();
2358               switch (op[2] & 0x00)
2359               {
2360                 case 0x00:
2361                   goto op_semantics_4;
2362                   break;
2363               }
2364             break;
2365           case 0x8f:
2366               GETBYTE ();
2367               switch (op[2] & 0x00)
2368               {
2369                 case 0x00:
2370                   goto op_semantics_4;
2371                   break;
2372               }
2373             break;
2374           case 0x90:
2375               GETBYTE ();
2376               switch (op[2] & 0x00)
2377               {
2378                 case 0x00:
2379                   goto op_semantics_5;
2380                   break;
2381               }
2382             break;
2383           case 0x91:
2384               GETBYTE ();
2385               switch (op[2] & 0x00)
2386               {
2387                 case 0x00:
2388                   goto op_semantics_5;
2389                   break;
2390               }
2391             break;
2392           case 0x92:
2393               GETBYTE ();
2394               switch (op[2] & 0x00)
2395               {
2396                 case 0x00:
2397                   goto op_semantics_5;
2398                   break;
2399               }
2400             break;
2401           case 0x93:
2402               GETBYTE ();
2403               switch (op[2] & 0x00)
2404               {
2405                 case 0x00:
2406                   goto op_semantics_5;
2407                   break;
2408               }
2409             break;
2410           case 0x94:
2411               GETBYTE ();
2412               switch (op[2] & 0x00)
2413               {
2414                 case 0x00:
2415                   goto op_semantics_6;
2416                   break;
2417               }
2418             break;
2419           case 0x95:
2420               GETBYTE ();
2421               switch (op[2] & 0x00)
2422               {
2423                 case 0x00:
2424                   goto op_semantics_6;
2425                   break;
2426               }
2427             break;
2428           case 0x96:
2429               GETBYTE ();
2430               switch (op[2] & 0x00)
2431               {
2432                 case 0x00:
2433                   goto op_semantics_6;
2434                   break;
2435               }
2436             break;
2437           case 0x97:
2438               GETBYTE ();
2439               switch (op[2] & 0x00)
2440               {
2441                 case 0x00:
2442                   goto op_semantics_6;
2443                   break;
2444               }
2445             break;
2446           case 0xa0:
2447               GETBYTE ();
2448               switch (op[2] & 0xff)
2449               {
2450                 case 0x00:
2451                     GETBYTE ();
2452                     switch (op[3] & 0x00)
2453                     {
2454                       case 0x00:
2455                         goto op_semantics_7;
2456                         break;
2457                     }
2458                   break;
2459                 case 0x02:
2460                     GETBYTE ();
2461                     switch (op[3] & 0x00)
2462                     {
2463                       case 0x00:
2464                         op_semantics_19:
2465                           {
2466                             /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc     %1%S1, %0 */
2467 #line 498 "rx-decode.opc"
2468                             int ss AU = op[1] & 0x03;
2469 #line 498 "rx-decode.opc"
2470                             int rsrc AU = (op[3] >> 4) & 0x0f;
2471 #line 498 "rx-decode.opc"
2472                             int rdst AU = op[3] & 0x0f;
2473                             if (trace)
2474                               {
2475                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
2476                                        "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst     adc     %1%S1, %0 */",
2477                                        op[0], op[1], op[2], op[3]);
2478                                 printf ("  ss = 0x%x,", ss);
2479                                 printf ("  rsrc = 0x%x,", rsrc);
2480                                 printf ("  rdst = 0x%x\n", rdst);
2481                               }
2482                             SYNTAX("adc %1%S1, %0");
2483 #line 498 "rx-decode.opc"
2484                             ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2485
2486                           /*----------------------------------------------------------------------*/
2487                           /* ADD                                                                        */
2488
2489                           }
2490                         break;
2491                     }
2492                   break;
2493                 case 0x04:
2494                     GETBYTE ();
2495                     switch (op[3] & 0x00)
2496                     {
2497                       case 0x00:
2498                         goto op_semantics_8;
2499                         break;
2500                     }
2501                   break;
2502                 case 0x05:
2503                     GETBYTE ();
2504                     switch (op[3] & 0x00)
2505                     {
2506                       case 0x00:
2507                         goto op_semantics_9;
2508                         break;
2509                     }
2510                   break;
2511                 case 0x06:
2512                     GETBYTE ();
2513                     switch (op[3] & 0x00)
2514                     {
2515                       case 0x00:
2516                         goto op_semantics_10;
2517                         break;
2518                     }
2519                   break;
2520                 case 0x07:
2521                     GETBYTE ();
2522                     switch (op[3] & 0x00)
2523                     {
2524                       case 0x00:
2525                         goto op_semantics_11;
2526                         break;
2527                     }
2528                   break;
2529                 case 0x08:
2530                     GETBYTE ();
2531                     switch (op[3] & 0x00)
2532                     {
2533                       case 0x00:
2534                         goto op_semantics_12;
2535                         break;
2536                     }
2537                   break;
2538                 case 0x09:
2539                     GETBYTE ();
2540                     switch (op[3] & 0x00)
2541                     {
2542                       case 0x00:
2543                         goto op_semantics_13;
2544                         break;
2545                     }
2546                   break;
2547                 case 0x0c:
2548                     GETBYTE ();
2549                     switch (op[3] & 0x00)
2550                     {
2551                       case 0x00:
2552                         goto op_semantics_14;
2553                         break;
2554                     }
2555                   break;
2556                 case 0x0d:
2557                     GETBYTE ();
2558                     switch (op[3] & 0x00)
2559                     {
2560                       case 0x00:
2561                         goto op_semantics_15;
2562                         break;
2563                     }
2564                   break;
2565                 case 0x10:
2566                     GETBYTE ();
2567                     switch (op[3] & 0x00)
2568                     {
2569                       case 0x00:
2570                         goto op_semantics_16;
2571                         break;
2572                     }
2573                   break;
2574                 case 0x11:
2575                     GETBYTE ();
2576                     switch (op[3] & 0x00)
2577                     {
2578                       case 0x00:
2579                         goto op_semantics_17;
2580                         break;
2581                     }
2582                   break;
2583                 case 0x15:
2584                     GETBYTE ();
2585                     switch (op[3] & 0x00)
2586                     {
2587                       case 0x00:
2588                         goto op_semantics_18;
2589                         break;
2590                     }
2591                   break;
2592                 default: UNSUPPORTED(); break;
2593               }
2594             break;
2595           case 0xa1:
2596               GETBYTE ();
2597               switch (op[2] & 0xff)
2598               {
2599                 case 0x00:
2600                     GETBYTE ();
2601                     switch (op[3] & 0x00)
2602                     {
2603                       case 0x00:
2604                         goto op_semantics_7;
2605                         break;
2606                     }
2607                   break;
2608                 case 0x02:
2609                     GETBYTE ();
2610                     switch (op[3] & 0x00)
2611                     {
2612                       case 0x00:
2613                         goto op_semantics_19;
2614                         break;
2615                     }
2616                   break;
2617                 case 0x04:
2618                     GETBYTE ();
2619                     switch (op[3] & 0x00)
2620                     {
2621                       case 0x00:
2622                         goto op_semantics_8;
2623                         break;
2624                     }
2625                   break;
2626                 case 0x05:
2627                     GETBYTE ();
2628                     switch (op[3] & 0x00)
2629                     {
2630                       case 0x00:
2631                         goto op_semantics_9;
2632                         break;
2633                     }
2634                   break;
2635                 case 0x06:
2636                     GETBYTE ();
2637                     switch (op[3] & 0x00)
2638                     {
2639                       case 0x00:
2640                         goto op_semantics_10;
2641                         break;
2642                     }
2643                   break;
2644                 case 0x07:
2645                     GETBYTE ();
2646                     switch (op[3] & 0x00)
2647                     {
2648                       case 0x00:
2649                         goto op_semantics_11;
2650                         break;
2651                     }
2652                   break;
2653                 case 0x08:
2654                     GETBYTE ();
2655                     switch (op[3] & 0x00)
2656                     {
2657                       case 0x00:
2658                         goto op_semantics_12;
2659                         break;
2660                     }
2661                   break;
2662                 case 0x09:
2663                     GETBYTE ();
2664                     switch (op[3] & 0x00)
2665                     {
2666                       case 0x00:
2667                         goto op_semantics_13;
2668                         break;
2669                     }
2670                   break;
2671                 case 0x0c:
2672                     GETBYTE ();
2673                     switch (op[3] & 0x00)
2674                     {
2675                       case 0x00:
2676                         goto op_semantics_14;
2677                         break;
2678                     }
2679                   break;
2680                 case 0x0d:
2681                     GETBYTE ();
2682                     switch (op[3] & 0x00)
2683                     {
2684                       case 0x00:
2685                         goto op_semantics_15;
2686                         break;
2687                     }
2688                   break;
2689                 case 0x10:
2690                     GETBYTE ();
2691                     switch (op[3] & 0x00)
2692                     {
2693                       case 0x00:
2694                         goto op_semantics_16;
2695                         break;
2696                     }
2697                   break;
2698                 case 0x11:
2699                     GETBYTE ();
2700                     switch (op[3] & 0x00)
2701                     {
2702                       case 0x00:
2703                         goto op_semantics_17;
2704                         break;
2705                     }
2706                   break;
2707                 case 0x15:
2708                     GETBYTE ();
2709                     switch (op[3] & 0x00)
2710                     {
2711                       case 0x00:
2712                         goto op_semantics_18;
2713                         break;
2714                     }
2715                   break;
2716                 default: UNSUPPORTED(); break;
2717               }
2718             break;
2719           case 0xa2:
2720               GETBYTE ();
2721               switch (op[2] & 0xff)
2722               {
2723                 case 0x00:
2724                     GETBYTE ();
2725                     switch (op[3] & 0x00)
2726                     {
2727                       case 0x00:
2728                         goto op_semantics_7;
2729                         break;
2730                     }
2731                   break;
2732                 case 0x02:
2733                     GETBYTE ();
2734                     switch (op[3] & 0x00)
2735                     {
2736                       case 0x00:
2737                         goto op_semantics_19;
2738                         break;
2739                     }
2740                   break;
2741                 case 0x04:
2742                     GETBYTE ();
2743                     switch (op[3] & 0x00)
2744                     {
2745                       case 0x00:
2746                         goto op_semantics_8;
2747                         break;
2748                     }
2749                   break;
2750                 case 0x05:
2751                     GETBYTE ();
2752                     switch (op[3] & 0x00)
2753                     {
2754                       case 0x00:
2755                         goto op_semantics_9;
2756                         break;
2757                     }
2758                   break;
2759                 case 0x06:
2760                     GETBYTE ();
2761                     switch (op[3] & 0x00)
2762                     {
2763                       case 0x00:
2764                         goto op_semantics_10;
2765                         break;
2766                     }
2767                   break;
2768                 case 0x07:
2769                     GETBYTE ();
2770                     switch (op[3] & 0x00)
2771                     {
2772                       case 0x00:
2773                         goto op_semantics_11;
2774                         break;
2775                     }
2776                   break;
2777                 case 0x08:
2778                     GETBYTE ();
2779                     switch (op[3] & 0x00)
2780                     {
2781                       case 0x00:
2782                         goto op_semantics_12;
2783                         break;
2784                     }
2785                   break;
2786                 case 0x09:
2787                     GETBYTE ();
2788                     switch (op[3] & 0x00)
2789                     {
2790                       case 0x00:
2791                         goto op_semantics_13;
2792                         break;
2793                     }
2794                   break;
2795                 case 0x0c:
2796                     GETBYTE ();
2797                     switch (op[3] & 0x00)
2798                     {
2799                       case 0x00:
2800                         goto op_semantics_14;
2801                         break;
2802                     }
2803                   break;
2804                 case 0x0d:
2805                     GETBYTE ();
2806                     switch (op[3] & 0x00)
2807                     {
2808                       case 0x00:
2809                         goto op_semantics_15;
2810                         break;
2811                     }
2812                   break;
2813                 case 0x10:
2814                     GETBYTE ();
2815                     switch (op[3] & 0x00)
2816                     {
2817                       case 0x00:
2818                         goto op_semantics_16;
2819                         break;
2820                     }
2821                   break;
2822                 case 0x11:
2823                     GETBYTE ();
2824                     switch (op[3] & 0x00)
2825                     {
2826                       case 0x00:
2827                         goto op_semantics_17;
2828                         break;
2829                     }
2830                   break;
2831                 case 0x15:
2832                     GETBYTE ();
2833                     switch (op[3] & 0x00)
2834                     {
2835                       case 0x00:
2836                         goto op_semantics_18;
2837                         break;
2838                     }
2839                   break;
2840                 default: UNSUPPORTED(); break;
2841               }
2842             break;
2843           case 0xa3:
2844               GETBYTE ();
2845               switch (op[2] & 0xff)
2846               {
2847                 case 0x00:
2848                     GETBYTE ();
2849                     switch (op[3] & 0x00)
2850                     {
2851                       case 0x00:
2852                         goto op_semantics_7;
2853                         break;
2854                     }
2855                   break;
2856                 case 0x02:
2857                     GETBYTE ();
2858                     switch (op[3] & 0x00)
2859                     {
2860                       case 0x00:
2861                         goto op_semantics_19;
2862                         break;
2863                     }
2864                   break;
2865                 case 0x04:
2866                     GETBYTE ();
2867                     switch (op[3] & 0x00)
2868                     {
2869                       case 0x00:
2870                         goto op_semantics_8;
2871                         break;
2872                     }
2873                   break;
2874                 case 0x05:
2875                     GETBYTE ();
2876                     switch (op[3] & 0x00)
2877                     {
2878                       case 0x00:
2879                         goto op_semantics_9;
2880                         break;
2881                     }
2882                   break;
2883                 case 0x06:
2884                     GETBYTE ();
2885                     switch (op[3] & 0x00)
2886                     {
2887                       case 0x00:
2888                         goto op_semantics_10;
2889                         break;
2890                     }
2891                   break;
2892                 case 0x07:
2893                     GETBYTE ();
2894                     switch (op[3] & 0x00)
2895                     {
2896                       case 0x00:
2897                         goto op_semantics_11;
2898                         break;
2899                     }
2900                   break;
2901                 case 0x08:
2902                     GETBYTE ();
2903                     switch (op[3] & 0x00)
2904                     {
2905                       case 0x00:
2906                         goto op_semantics_12;
2907                         break;
2908                     }
2909                   break;
2910                 case 0x09:
2911                     GETBYTE ();
2912                     switch (op[3] & 0x00)
2913                     {
2914                       case 0x00:
2915                         goto op_semantics_13;
2916                         break;
2917                     }
2918                   break;
2919                 case 0x0c:
2920                     GETBYTE ();
2921                     switch (op[3] & 0x00)
2922                     {
2923                       case 0x00:
2924                         goto op_semantics_14;
2925                         break;
2926                     }
2927                   break;
2928                 case 0x0d:
2929                     GETBYTE ();
2930                     switch (op[3] & 0x00)
2931                     {
2932                       case 0x00:
2933                         goto op_semantics_15;
2934                         break;
2935                     }
2936                   break;
2937                 case 0x10:
2938                     GETBYTE ();
2939                     switch (op[3] & 0x00)
2940                     {
2941                       case 0x00:
2942                         goto op_semantics_16;
2943                         break;
2944                     }
2945                   break;
2946                 case 0x11:
2947                     GETBYTE ();
2948                     switch (op[3] & 0x00)
2949                     {
2950                       case 0x00:
2951                         goto op_semantics_17;
2952                         break;
2953                     }
2954                   break;
2955                 case 0x15:
2956                     GETBYTE ();
2957                     switch (op[3] & 0x00)
2958                     {
2959                       case 0x00:
2960                         goto op_semantics_18;
2961                         break;
2962                     }
2963                   break;
2964                 default: UNSUPPORTED(); break;
2965               }
2966             break;
2967           case 0xc0:
2968               GETBYTE ();
2969               switch (op[2] & 0x00)
2970               {
2971                 case 0x00:
2972                   goto op_semantics_1;
2973                   break;
2974               }
2975             break;
2976           case 0xc1:
2977               GETBYTE ();
2978               switch (op[2] & 0x00)
2979               {
2980                 case 0x00:
2981                   goto op_semantics_1;
2982                   break;
2983               }
2984             break;
2985           case 0xc2:
2986               GETBYTE ();
2987               switch (op[2] & 0x00)
2988               {
2989                 case 0x00:
2990                   goto op_semantics_1;
2991                   break;
2992               }
2993             break;
2994           case 0xc3:
2995               GETBYTE ();
2996               switch (op[2] & 0x00)
2997               {
2998                 case 0x00:
2999                   goto op_semantics_1;
3000                   break;
3001               }
3002             break;
3003           case 0xc4:
3004               GETBYTE ();
3005               switch (op[2] & 0x00)
3006               {
3007                 case 0x00:
3008                   goto op_semantics_2;
3009                   break;
3010               }
3011             break;
3012           case 0xc5:
3013               GETBYTE ();
3014               switch (op[2] & 0x00)
3015               {
3016                 case 0x00:
3017                   goto op_semantics_2;
3018                   break;
3019               }
3020             break;
3021           case 0xc6:
3022               GETBYTE ();
3023               switch (op[2] & 0x00)
3024               {
3025                 case 0x00:
3026                   goto op_semantics_2;
3027                   break;
3028               }
3029             break;
3030           case 0xc7:
3031               GETBYTE ();
3032               switch (op[2] & 0x00)
3033               {
3034                 case 0x00:
3035                   goto op_semantics_2;
3036                   break;
3037               }
3038             break;
3039           case 0xc8:
3040               GETBYTE ();
3041               switch (op[2] & 0x00)
3042               {
3043                 case 0x00:
3044                   goto op_semantics_3;
3045                   break;
3046               }
3047             break;
3048           case 0xc9:
3049               GETBYTE ();
3050               switch (op[2] & 0x00)
3051               {
3052                 case 0x00:
3053                   goto op_semantics_3;
3054                   break;
3055               }
3056             break;
3057           case 0xca:
3058               GETBYTE ();
3059               switch (op[2] & 0x00)
3060               {
3061                 case 0x00:
3062                   goto op_semantics_3;
3063                   break;
3064               }
3065             break;
3066           case 0xcb:
3067               GETBYTE ();
3068               switch (op[2] & 0x00)
3069               {
3070                 case 0x00:
3071                   goto op_semantics_3;
3072                   break;
3073               }
3074             break;
3075           case 0xcc:
3076               GETBYTE ();
3077               switch (op[2] & 0x00)
3078               {
3079                 case 0x00:
3080                   goto op_semantics_4;
3081                   break;
3082               }
3083             break;
3084           case 0xcd:
3085               GETBYTE ();
3086               switch (op[2] & 0x00)
3087               {
3088                 case 0x00:
3089                   goto op_semantics_4;
3090                   break;
3091               }
3092             break;
3093           case 0xce:
3094               GETBYTE ();
3095               switch (op[2] & 0x00)
3096               {
3097                 case 0x00:
3098                   goto op_semantics_4;
3099                   break;
3100               }
3101             break;
3102           case 0xcf:
3103               GETBYTE ();
3104               switch (op[2] & 0x00)
3105               {
3106                 case 0x00:
3107                   goto op_semantics_4;
3108                   break;
3109               }
3110             break;
3111           case 0xd0:
3112               GETBYTE ();
3113               switch (op[2] & 0x00)
3114               {
3115                 case 0x00:
3116                   goto op_semantics_5;
3117                   break;
3118               }
3119             break;
3120           case 0xd1:
3121               GETBYTE ();
3122               switch (op[2] & 0x00)
3123               {
3124                 case 0x00:
3125                   goto op_semantics_5;
3126                   break;
3127               }
3128             break;
3129           case 0xd2:
3130               GETBYTE ();
3131               switch (op[2] & 0x00)
3132               {
3133                 case 0x00:
3134                   goto op_semantics_5;
3135                   break;
3136               }
3137             break;
3138           case 0xd3:
3139               GETBYTE ();
3140               switch (op[2] & 0x00)
3141               {
3142                 case 0x00:
3143                   goto op_semantics_5;
3144                   break;
3145               }
3146             break;
3147           case 0xd4:
3148               GETBYTE ();
3149               switch (op[2] & 0x00)
3150               {
3151                 case 0x00:
3152                   goto op_semantics_6;
3153                   break;
3154               }
3155             break;
3156           case 0xd5:
3157               GETBYTE ();
3158               switch (op[2] & 0x00)
3159               {
3160                 case 0x00:
3161                   goto op_semantics_6;
3162                   break;
3163               }
3164             break;
3165           case 0xd6:
3166               GETBYTE ();
3167               switch (op[2] & 0x00)
3168               {
3169                 case 0x00:
3170                   goto op_semantics_6;
3171                   break;
3172               }
3173             break;
3174           case 0xd7:
3175               GETBYTE ();
3176               switch (op[2] & 0x00)
3177               {
3178                 case 0x00:
3179                   goto op_semantics_6;
3180                   break;
3181               }
3182             break;
3183           case 0xe0:
3184               GETBYTE ();
3185               switch (op[2] & 0xff)
3186               {
3187                 case 0x00:
3188                     GETBYTE ();
3189                     switch (op[3] & 0x00)
3190                     {
3191                       case 0x00:
3192                         goto op_semantics_7;
3193                         break;
3194                     }
3195                   break;
3196                 case 0x04:
3197                     GETBYTE ();
3198                     switch (op[3] & 0x00)
3199                     {
3200                       case 0x00:
3201                         goto op_semantics_8;
3202                         break;
3203                     }
3204                   break;
3205                 case 0x05:
3206                     GETBYTE ();
3207                     switch (op[3] & 0x00)
3208                     {
3209                       case 0x00:
3210                         goto op_semantics_9;
3211                         break;
3212                     }
3213                   break;
3214                 case 0x06:
3215                     GETBYTE ();
3216                     switch (op[3] & 0x00)
3217                     {
3218                       case 0x00:
3219                         goto op_semantics_10;
3220                         break;
3221                     }
3222                   break;
3223                 case 0x07:
3224                     GETBYTE ();
3225                     switch (op[3] & 0x00)
3226                     {
3227                       case 0x00:
3228                         goto op_semantics_11;
3229                         break;
3230                     }
3231                   break;
3232                 case 0x08:
3233                     GETBYTE ();
3234                     switch (op[3] & 0x00)
3235                     {
3236                       case 0x00:
3237                         goto op_semantics_12;
3238                         break;
3239                     }
3240                   break;
3241                 case 0x09:
3242                     GETBYTE ();
3243                     switch (op[3] & 0x00)
3244                     {
3245                       case 0x00:
3246                         goto op_semantics_13;
3247                         break;
3248                     }
3249                   break;
3250                 case 0x0c:
3251                     GETBYTE ();
3252                     switch (op[3] & 0x00)
3253                     {
3254                       case 0x00:
3255                         goto op_semantics_14;
3256                         break;
3257                     }
3258                   break;
3259                 case 0x0d:
3260                     GETBYTE ();
3261                     switch (op[3] & 0x00)
3262                     {
3263                       case 0x00:
3264                         goto op_semantics_15;
3265                         break;
3266                     }
3267                   break;
3268                 case 0x10:
3269                     GETBYTE ();
3270                     switch (op[3] & 0x00)
3271                     {
3272                       case 0x00:
3273                         goto op_semantics_16;
3274                         break;
3275                     }
3276                   break;
3277                 case 0x11:
3278                     GETBYTE ();
3279                     switch (op[3] & 0x00)
3280                     {
3281                       case 0x00:
3282                         goto op_semantics_17;
3283                         break;
3284                     }
3285                   break;
3286                 case 0x15:
3287                     GETBYTE ();
3288                     switch (op[3] & 0x00)
3289                     {
3290                       case 0x00:
3291                         goto op_semantics_18;
3292                         break;
3293                     }
3294                   break;
3295                 default: UNSUPPORTED(); break;
3296               }
3297             break;
3298           case 0xe1:
3299               GETBYTE ();
3300               switch (op[2] & 0xff)
3301               {
3302                 case 0x00:
3303                     GETBYTE ();
3304                     switch (op[3] & 0x00)
3305                     {
3306                       case 0x00:
3307                         goto op_semantics_7;
3308                         break;
3309                     }
3310                   break;
3311                 case 0x04:
3312                     GETBYTE ();
3313                     switch (op[3] & 0x00)
3314                     {
3315                       case 0x00:
3316                         goto op_semantics_8;
3317                         break;
3318                     }
3319                   break;
3320                 case 0x05:
3321                     GETBYTE ();
3322                     switch (op[3] & 0x00)
3323                     {
3324                       case 0x00:
3325                         goto op_semantics_9;
3326                         break;
3327                     }
3328                   break;
3329                 case 0x06:
3330                     GETBYTE ();
3331                     switch (op[3] & 0x00)
3332                     {
3333                       case 0x00:
3334                         goto op_semantics_10;
3335                         break;
3336                     }
3337                   break;
3338                 case 0x07:
3339                     GETBYTE ();
3340                     switch (op[3] & 0x00)
3341                     {
3342                       case 0x00:
3343                         goto op_semantics_11;
3344                         break;
3345                     }
3346                   break;
3347                 case 0x08:
3348                     GETBYTE ();
3349                     switch (op[3] & 0x00)
3350                     {
3351                       case 0x00:
3352                         goto op_semantics_12;
3353                         break;
3354                     }
3355                   break;
3356                 case 0x09:
3357                     GETBYTE ();
3358                     switch (op[3] & 0x00)
3359                     {
3360                       case 0x00:
3361                         goto op_semantics_13;
3362                         break;
3363                     }
3364                   break;
3365                 case 0x0c:
3366                     GETBYTE ();
3367                     switch (op[3] & 0x00)
3368                     {
3369                       case 0x00:
3370                         goto op_semantics_14;
3371                         break;
3372                     }
3373                   break;
3374                 case 0x0d:
3375                     GETBYTE ();
3376                     switch (op[3] & 0x00)
3377                     {
3378                       case 0x00:
3379                         goto op_semantics_15;
3380                         break;
3381                     }
3382                   break;
3383                 case 0x10:
3384                     GETBYTE ();
3385                     switch (op[3] & 0x00)
3386                     {
3387                       case 0x00:
3388                         goto op_semantics_16;
3389                         break;
3390                     }
3391                   break;
3392                 case 0x11:
3393                     GETBYTE ();
3394                     switch (op[3] & 0x00)
3395                     {
3396                       case 0x00:
3397                         goto op_semantics_17;
3398                         break;
3399                     }
3400                   break;
3401                 case 0x15:
3402                     GETBYTE ();
3403                     switch (op[3] & 0x00)
3404                     {
3405                       case 0x00:
3406                         goto op_semantics_18;
3407                         break;
3408                     }
3409                   break;
3410                 default: UNSUPPORTED(); break;
3411               }
3412             break;
3413           case 0xe2:
3414               GETBYTE ();
3415               switch (op[2] & 0xff)
3416               {
3417                 case 0x00:
3418                     GETBYTE ();
3419                     switch (op[3] & 0x00)
3420                     {
3421                       case 0x00:
3422                         goto op_semantics_7;
3423                         break;
3424                     }
3425                   break;
3426                 case 0x04:
3427                     GETBYTE ();
3428                     switch (op[3] & 0x00)
3429                     {
3430                       case 0x00:
3431                         goto op_semantics_8;
3432                         break;
3433                     }
3434                   break;
3435                 case 0x05:
3436                     GETBYTE ();
3437                     switch (op[3] & 0x00)
3438                     {
3439                       case 0x00:
3440                         goto op_semantics_9;
3441                         break;
3442                     }
3443                   break;
3444                 case 0x06:
3445                     GETBYTE ();
3446                     switch (op[3] & 0x00)
3447                     {
3448                       case 0x00:
3449                         goto op_semantics_10;
3450                         break;
3451                     }
3452                   break;
3453                 case 0x07:
3454                     GETBYTE ();
3455                     switch (op[3] & 0x00)
3456                     {
3457                       case 0x00:
3458                         goto op_semantics_11;
3459                         break;
3460                     }
3461                   break;
3462                 case 0x08:
3463                     GETBYTE ();
3464                     switch (op[3] & 0x00)
3465                     {
3466                       case 0x00:
3467                         goto op_semantics_12;
3468                         break;
3469                     }
3470                   break;
3471                 case 0x09:
3472                     GETBYTE ();
3473                     switch (op[3] & 0x00)
3474                     {
3475                       case 0x00:
3476                         goto op_semantics_13;
3477                         break;
3478                     }
3479                   break;
3480                 case 0x0c:
3481                     GETBYTE ();
3482                     switch (op[3] & 0x00)
3483                     {
3484                       case 0x00:
3485                         goto op_semantics_14;
3486                         break;
3487                     }
3488                   break;
3489                 case 0x0d:
3490                     GETBYTE ();
3491                     switch (op[3] & 0x00)
3492                     {
3493                       case 0x00:
3494                         goto op_semantics_15;
3495                         break;
3496                     }
3497                   break;
3498                 case 0x10:
3499                     GETBYTE ();
3500                     switch (op[3] & 0x00)
3501                     {
3502                       case 0x00:
3503                         goto op_semantics_16;
3504                         break;
3505                     }
3506                   break;
3507                 case 0x11:
3508                     GETBYTE ();
3509                     switch (op[3] & 0x00)
3510                     {
3511                       case 0x00:
3512                         goto op_semantics_17;
3513                         break;
3514                     }
3515                   break;
3516                 case 0x15:
3517                     GETBYTE ();
3518                     switch (op[3] & 0x00)
3519                     {
3520                       case 0x00:
3521                         goto op_semantics_18;
3522                         break;
3523                     }
3524                   break;
3525                 default: UNSUPPORTED(); break;
3526               }
3527             break;
3528           case 0xe3:
3529               GETBYTE ();
3530               switch (op[2] & 0xff)
3531               {
3532                 case 0x00:
3533                     GETBYTE ();
3534                     switch (op[3] & 0x00)
3535                     {
3536                       case 0x00:
3537                         goto op_semantics_7;
3538                         break;
3539                     }
3540                   break;
3541                 case 0x04:
3542                     GETBYTE ();
3543                     switch (op[3] & 0x00)
3544                     {
3545                       case 0x00:
3546                         goto op_semantics_8;
3547                         break;
3548                     }
3549                   break;
3550                 case 0x05:
3551                     GETBYTE ();
3552                     switch (op[3] & 0x00)
3553                     {
3554                       case 0x00:
3555                         goto op_semantics_9;
3556                         break;
3557                     }
3558                   break;
3559                 case 0x06:
3560                     GETBYTE ();
3561                     switch (op[3] & 0x00)
3562                     {
3563                       case 0x00:
3564                         goto op_semantics_10;
3565                         break;
3566                     }
3567                   break;
3568                 case 0x07:
3569                     GETBYTE ();
3570                     switch (op[3] & 0x00)
3571                     {
3572                       case 0x00:
3573                         goto op_semantics_11;
3574                         break;
3575                     }
3576                   break;
3577                 case 0x08:
3578                     GETBYTE ();
3579                     switch (op[3] & 0x00)
3580                     {
3581                       case 0x00:
3582                         goto op_semantics_12;
3583                         break;
3584                     }
3585                   break;
3586                 case 0x09:
3587                     GETBYTE ();
3588                     switch (op[3] & 0x00)
3589                     {
3590                       case 0x00:
3591                         goto op_semantics_13;
3592                         break;
3593                     }
3594                   break;
3595                 case 0x0c:
3596                     GETBYTE ();
3597                     switch (op[3] & 0x00)
3598                     {
3599                       case 0x00:
3600                         goto op_semantics_14;
3601                         break;
3602                     }
3603                   break;
3604                 case 0x0d:
3605                     GETBYTE ();
3606                     switch (op[3] & 0x00)
3607                     {
3608                       case 0x00:
3609                         goto op_semantics_15;
3610                         break;
3611                     }
3612                   break;
3613                 case 0x10:
3614                     GETBYTE ();
3615                     switch (op[3] & 0x00)
3616                     {
3617                       case 0x00:
3618                         goto op_semantics_16;
3619                         break;
3620                     }
3621                   break;
3622                 case 0x11:
3623                     GETBYTE ();
3624                     switch (op[3] & 0x00)
3625                     {
3626                       case 0x00:
3627                         goto op_semantics_17;
3628                         break;
3629                     }
3630                   break;
3631                 case 0x15:
3632                     GETBYTE ();
3633                     switch (op[3] & 0x00)
3634                     {
3635                       case 0x00:
3636                         goto op_semantics_18;
3637                         break;
3638                     }
3639                   break;
3640                 default: UNSUPPORTED(); break;
3641               }
3642             break;
3643           default: UNSUPPORTED(); break;
3644         }
3645       break;
3646     case 0x08:
3647     case 0x09:
3648     case 0x0a:
3649     case 0x0b:
3650     case 0x0c:
3651     case 0x0d:
3652     case 0x0e:
3653     case 0x0f:
3654         {
3655           /** 0000 1dsp                 bra.s   %a0 */
3656 #line 779 "rx-decode.opc"
3657           int dsp AU = op[0] & 0x07;
3658           if (trace)
3659             {
3660               printf ("\033[33m%s\033[0m  %02x\n",
3661                      "/** 0000 1dsp                     bra.s   %a0 */",
3662                      op[0]);
3663               printf ("  dsp = 0x%x\n", dsp);
3664             }
3665           SYNTAX("bra.s %a0");
3666 #line 779 "rx-decode.opc"
3667           ID(branch); DC(pc + dsp3map[dsp]);
3668
3669         }
3670       break;
3671     case 0x10:
3672     case 0x11:
3673     case 0x12:
3674     case 0x13:
3675     case 0x14:
3676     case 0x15:
3677     case 0x16:
3678     case 0x17:
3679     case 0x18:
3680     case 0x19:
3681     case 0x1a:
3682     case 0x1b:
3683     case 0x1c:
3684     case 0x1d:
3685     case 0x1e:
3686     case 0x1f:
3687         {
3688           /** 0001 n dsp                        b%1.s   %a0 */
3689 #line 769 "rx-decode.opc"
3690           int n AU = (op[0] >> 3) & 0x01;
3691 #line 769 "rx-decode.opc"
3692           int dsp AU = op[0] & 0x07;
3693           if (trace)
3694             {
3695               printf ("\033[33m%s\033[0m  %02x\n",
3696                      "/** 0001 n dsp                    b%1.s   %a0 */",
3697                      op[0]);
3698               printf ("  n = 0x%x,", n);
3699               printf ("  dsp = 0x%x\n", dsp);
3700             }
3701           SYNTAX("b%1.s %a0");
3702 #line 769 "rx-decode.opc"
3703           ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3704
3705         }
3706       break;
3707     case 0x20:
3708     case 0x21:
3709     case 0x22:
3710     case 0x23:
3711     case 0x24:
3712     case 0x25:
3713     case 0x26:
3714     case 0x27:
3715     case 0x28:
3716     case 0x29:
3717     case 0x2a:
3718     case 0x2b:
3719     case 0x2c:
3720     case 0x2d:
3721     case 0x2f:
3722         {
3723           /** 0010 cond                 b%1.b   %a0 */
3724 #line 772 "rx-decode.opc"
3725           int cond AU = op[0] & 0x0f;
3726           if (trace)
3727             {
3728               printf ("\033[33m%s\033[0m  %02x\n",
3729                      "/** 0010 cond                     b%1.b   %a0 */",
3730                      op[0]);
3731               printf ("  cond = 0x%x\n", cond);
3732             }
3733           SYNTAX("b%1.b %a0");
3734 #line 772 "rx-decode.opc"
3735           ID(branch); Scc(cond); DC(pc + IMMex (1));
3736
3737         }
3738       break;
3739     case 0x2e:
3740         {
3741           /** 0010 1110                 bra.b   %a0 */
3742           if (trace)
3743             {
3744               printf ("\033[33m%s\033[0m  %02x\n",
3745                      "/** 0010 1110                     bra.b   %a0 */",
3746                      op[0]);
3747             }
3748           SYNTAX("bra.b %a0");
3749 #line 782 "rx-decode.opc"
3750           ID(branch); DC(pc + IMMex(1));
3751
3752         }
3753       break;
3754     case 0x38:
3755         {
3756           /** 0011 1000                 bra.w   %a0 */
3757           if (trace)
3758             {
3759               printf ("\033[33m%s\033[0m  %02x\n",
3760                      "/** 0011 1000                     bra.w   %a0 */",
3761                      op[0]);
3762             }
3763           SYNTAX("bra.w %a0");
3764 #line 785 "rx-decode.opc"
3765           ID(branch); DC(pc + IMMex(2));
3766
3767         }
3768       break;
3769     case 0x39:
3770         {
3771           /** 0011 1001                 bsr.w   %a0 */
3772           if (trace)
3773             {
3774               printf ("\033[33m%s\033[0m  %02x\n",
3775                      "/** 0011 1001                     bsr.w   %a0 */",
3776                      op[0]);
3777             }
3778           SYNTAX("bsr.w %a0");
3779 #line 801 "rx-decode.opc"
3780           ID(jsr); DC(pc + IMMex(2));
3781
3782         }
3783       break;
3784     case 0x3a:
3785     case 0x3b:
3786         {
3787           /** 0011 101c                 b%1.w   %a0 */
3788 #line 775 "rx-decode.opc"
3789           int c AU = op[0] & 0x01;
3790           if (trace)
3791             {
3792               printf ("\033[33m%s\033[0m  %02x\n",
3793                      "/** 0011 101c                     b%1.w   %a0 */",
3794                      op[0]);
3795               printf ("  c = 0x%x\n", c);
3796             }
3797           SYNTAX("b%1.w %a0");
3798 #line 775 "rx-decode.opc"
3799           ID(branch); Scc(c); DC(pc + IMMex (2));
3800
3801
3802         }
3803       break;
3804     case 0x3c:
3805         GETBYTE ();
3806         switch (op[1] & 0x00)
3807         {
3808           case 0x00:
3809             op_semantics_20:
3810               {
3811                 /** 0011 11sz d dst sppp                mov%s   #%1, %0 */
3812 #line 311 "rx-decode.opc"
3813                 int sz AU = op[0] & 0x03;
3814 #line 311 "rx-decode.opc"
3815                 int d AU = (op[1] >> 7) & 0x01;
3816 #line 311 "rx-decode.opc"
3817                 int dst AU = (op[1] >> 4) & 0x07;
3818 #line 311 "rx-decode.opc"
3819                 int sppp AU = op[1] & 0x0f;
3820                 if (trace)
3821                   {
3822                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3823                            "/** 0011 11sz d dst sppp            mov%s   #%1, %0 */",
3824                            op[0], op[1]);
3825                     printf ("  sz = 0x%x,", sz);
3826                     printf ("  d = 0x%x,", d);
3827                     printf ("  dst = 0x%x,", dst);
3828                     printf ("  sppp = 0x%x\n", sppp);
3829                   }
3830                 SYNTAX("mov%s   #%1, %0");
3831 #line 311 "rx-decode.opc"
3832                 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3833
3834               }
3835             break;
3836         }
3837       break;
3838     case 0x3d:
3839         GETBYTE ();
3840         switch (op[1] & 0x00)
3841         {
3842           case 0x00:
3843             goto op_semantics_20;
3844             break;
3845         }
3846       break;
3847     case 0x3e:
3848         GETBYTE ();
3849         switch (op[1] & 0x00)
3850         {
3851           case 0x00:
3852             goto op_semantics_20;
3853             break;
3854         }
3855       break;
3856     case 0x3f:
3857         GETBYTE ();
3858         switch (op[1] & 0x00)
3859         {
3860           case 0x00:
3861               {
3862                 /** 0011 1111 rega regb         rtsd    #%1, %2-%0 */
3863 #line 408 "rx-decode.opc"
3864                 int rega AU = (op[1] >> 4) & 0x0f;
3865 #line 408 "rx-decode.opc"
3866                 int regb AU = op[1] & 0x0f;
3867                 if (trace)
3868                   {
3869                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3870                            "/** 0011 1111 rega regb             rtsd    #%1, %2-%0 */",
3871                            op[0], op[1]);
3872                     printf ("  rega = 0x%x,", rega);
3873                     printf ("  regb = 0x%x\n", regb);
3874                   }
3875                 SYNTAX("rtsd    #%1, %2-%0");
3876 #line 408 "rx-decode.opc"
3877                 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3878
3879               /*----------------------------------------------------------------------*/
3880               /* AND                                                                    */
3881
3882               }
3883             break;
3884         }
3885       break;
3886     case 0x40:
3887         GETBYTE ();
3888         switch (op[1] & 0x00)
3889         {
3890           case 0x00:
3891             op_semantics_21:
3892               {
3893                 /** 0100 00ss rsrc rdst                 sub     %2%S2, %1 */
3894 #line 543 "rx-decode.opc"
3895                 int ss AU = op[0] & 0x03;
3896 #line 543 "rx-decode.opc"
3897                 int rsrc AU = (op[1] >> 4) & 0x0f;
3898 #line 543 "rx-decode.opc"
3899                 int rdst AU = op[1] & 0x0f;
3900                 if (trace)
3901                   {
3902                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3903                            "/** 0100 00ss rsrc rdst                     sub     %2%S2, %1 */",
3904                            op[0], op[1]);
3905                     printf ("  ss = 0x%x,", ss);
3906                     printf ("  rsrc = 0x%x,", rsrc);
3907                     printf ("  rdst = 0x%x\n", rdst);
3908                   }
3909                 SYNTAX("sub     %2%S2, %1");
3910 #line 543 "rx-decode.opc"
3911                 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3912
3913               }
3914             break;
3915         }
3916       break;
3917     case 0x41:
3918         GETBYTE ();
3919         switch (op[1] & 0x00)
3920         {
3921           case 0x00:
3922             goto op_semantics_21;
3923             break;
3924         }
3925       break;
3926     case 0x42:
3927         GETBYTE ();
3928         switch (op[1] & 0x00)
3929         {
3930           case 0x00:
3931             goto op_semantics_21;
3932             break;
3933         }
3934       break;
3935     case 0x43:
3936         GETBYTE ();
3937         switch (op[1] & 0x00)
3938         {
3939           case 0x00:
3940             goto op_semantics_21;
3941             break;
3942         }
3943       break;
3944     case 0x44:
3945         GETBYTE ();
3946         switch (op[1] & 0x00)
3947         {
3948           case 0x00:
3949             op_semantics_22:
3950               {
3951                 /** 0100 01ss rsrc rdst         cmp     %2%S2, %1 */
3952 #line 531 "rx-decode.opc"
3953                 int ss AU = op[0] & 0x03;
3954 #line 531 "rx-decode.opc"
3955                 int rsrc AU = (op[1] >> 4) & 0x0f;
3956 #line 531 "rx-decode.opc"
3957                 int rdst AU = op[1] & 0x0f;
3958                 if (trace)
3959                   {
3960                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3961                            "/** 0100 01ss rsrc rdst             cmp     %2%S2, %1 */",
3962                            op[0], op[1]);
3963                     printf ("  ss = 0x%x,", ss);
3964                     printf ("  rsrc = 0x%x,", rsrc);
3965                     printf ("  rdst = 0x%x\n", rdst);
3966                   }
3967                 SYNTAX("cmp     %2%S2, %1");
3968 #line 531 "rx-decode.opc"
3969                 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3970
3971               }
3972             break;
3973         }
3974       break;
3975     case 0x45:
3976         GETBYTE ();
3977         switch (op[1] & 0x00)
3978         {
3979           case 0x00:
3980             goto op_semantics_22;
3981             break;
3982         }
3983       break;
3984     case 0x46:
3985         GETBYTE ();
3986         switch (op[1] & 0x00)
3987         {
3988           case 0x00:
3989             goto op_semantics_22;
3990             break;
3991         }
3992       break;
3993     case 0x47:
3994         GETBYTE ();
3995         switch (op[1] & 0x00)
3996         {
3997           case 0x00:
3998             goto op_semantics_22;
3999             break;
4000         }
4001       break;
4002     case 0x48:
4003         GETBYTE ();
4004         switch (op[1] & 0x00)
4005         {
4006           case 0x00:
4007             op_semantics_23:
4008               {
4009                 /** 0100 10ss rsrc rdst                 add     %1%S1, %0 */
4010 #line 507 "rx-decode.opc"
4011                 int ss AU = op[0] & 0x03;
4012 #line 507 "rx-decode.opc"
4013                 int rsrc AU = (op[1] >> 4) & 0x0f;
4014 #line 507 "rx-decode.opc"
4015                 int rdst AU = op[1] & 0x0f;
4016                 if (trace)
4017                   {
4018                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4019                            "/** 0100 10ss rsrc rdst                     add     %1%S1, %0 */",
4020                            op[0], op[1]);
4021                     printf ("  ss = 0x%x,", ss);
4022                     printf ("  rsrc = 0x%x,", rsrc);
4023                     printf ("  rdst = 0x%x\n", rdst);
4024                   }
4025                 SYNTAX("add     %1%S1, %0");
4026 #line 507 "rx-decode.opc"
4027                 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
4028
4029               }
4030             break;
4031         }
4032       break;
4033     case 0x49:
4034         GETBYTE ();
4035         switch (op[1] & 0x00)
4036         {
4037           case 0x00:
4038             goto op_semantics_23;
4039             break;
4040         }
4041       break;
4042     case 0x4a:
4043         GETBYTE ();
4044         switch (op[1] & 0x00)
4045         {
4046           case 0x00:
4047             goto op_semantics_23;
4048             break;
4049         }
4050       break;
4051     case 0x4b:
4052         GETBYTE ();
4053         switch (op[1] & 0x00)
4054         {
4055           case 0x00:
4056             goto op_semantics_23;
4057             break;
4058         }
4059       break;
4060     case 0x4c:
4061         GETBYTE ();
4062         switch (op[1] & 0x00)
4063         {
4064           case 0x00:
4065             op_semantics_24:
4066               {
4067                 /** 0100 11ss rsrc rdst                 mul     %1%S1, %0 */
4068 #line 650 "rx-decode.opc"
4069                 int ss AU = op[0] & 0x03;
4070 #line 650 "rx-decode.opc"
4071                 int rsrc AU = (op[1] >> 4) & 0x0f;
4072 #line 650 "rx-decode.opc"
4073                 int rdst AU = op[1] & 0x0f;
4074                 if (trace)
4075                   {
4076                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4077                            "/** 0100 11ss rsrc rdst                     mul     %1%S1, %0 */",
4078                            op[0], op[1]);
4079                     printf ("  ss = 0x%x,", ss);
4080                     printf ("  rsrc = 0x%x,", rsrc);
4081                     printf ("  rdst = 0x%x\n", rdst);
4082                   }
4083                 SYNTAX("mul     %1%S1, %0");
4084 #line 650 "rx-decode.opc"
4085                 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
4086
4087               }
4088             break;
4089         }
4090       break;
4091     case 0x4d:
4092         GETBYTE ();
4093         switch (op[1] & 0x00)
4094         {
4095           case 0x00:
4096             goto op_semantics_24;
4097             break;
4098         }
4099       break;
4100     case 0x4e:
4101         GETBYTE ();
4102         switch (op[1] & 0x00)
4103         {
4104           case 0x00:
4105             goto op_semantics_24;
4106             break;
4107         }
4108       break;
4109     case 0x4f:
4110         GETBYTE ();
4111         switch (op[1] & 0x00)
4112         {
4113           case 0x00:
4114             goto op_semantics_24;
4115             break;
4116         }
4117       break;
4118     case 0x50:
4119         GETBYTE ();
4120         switch (op[1] & 0x00)
4121         {
4122           case 0x00:
4123             op_semantics_25:
4124               {
4125                 /** 0101 00ss rsrc rdst                 and     %1%S1, %0 */
4126 #line 420 "rx-decode.opc"
4127                 int ss AU = op[0] & 0x03;
4128 #line 420 "rx-decode.opc"
4129                 int rsrc AU = (op[1] >> 4) & 0x0f;
4130 #line 420 "rx-decode.opc"
4131                 int rdst AU = op[1] & 0x0f;
4132                 if (trace)
4133                   {
4134                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4135                            "/** 0101 00ss rsrc rdst                     and     %1%S1, %0 */",
4136                            op[0], op[1]);
4137                     printf ("  ss = 0x%x,", ss);
4138                     printf ("  rsrc = 0x%x,", rsrc);
4139                     printf ("  rdst = 0x%x\n", rdst);
4140                   }
4141                 SYNTAX("and     %1%S1, %0");
4142 #line 420 "rx-decode.opc"
4143                 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
4144
4145               }
4146             break;
4147         }
4148       break;
4149     case 0x51:
4150         GETBYTE ();
4151         switch (op[1] & 0x00)
4152         {
4153           case 0x00:
4154             goto op_semantics_25;
4155             break;
4156         }
4157       break;
4158     case 0x52:
4159         GETBYTE ();
4160         switch (op[1] & 0x00)
4161         {
4162           case 0x00:
4163             goto op_semantics_25;
4164             break;
4165         }
4166       break;
4167     case 0x53:
4168         GETBYTE ();
4169         switch (op[1] & 0x00)
4170         {
4171           case 0x00:
4172             goto op_semantics_25;
4173             break;
4174         }
4175       break;
4176     case 0x54:
4177         GETBYTE ();
4178         switch (op[1] & 0x00)
4179         {
4180           case 0x00:
4181             op_semantics_26:
4182               {
4183                 /** 0101 01ss rsrc rdst                 or      %1%S1, %0 */
4184 #line 438 "rx-decode.opc"
4185                 int ss AU = op[0] & 0x03;
4186 #line 438 "rx-decode.opc"
4187                 int rsrc AU = (op[1] >> 4) & 0x0f;
4188 #line 438 "rx-decode.opc"
4189                 int rdst AU = op[1] & 0x0f;
4190                 if (trace)
4191                   {
4192                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4193                            "/** 0101 01ss rsrc rdst                     or      %1%S1, %0 */",
4194                            op[0], op[1]);
4195                     printf ("  ss = 0x%x,", ss);
4196                     printf ("  rsrc = 0x%x,", rsrc);
4197                     printf ("  rdst = 0x%x\n", rdst);
4198                   }
4199                 SYNTAX("or      %1%S1, %0");
4200 #line 438 "rx-decode.opc"
4201                 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4202
4203               }
4204             break;
4205         }
4206       break;
4207     case 0x55:
4208         GETBYTE ();
4209         switch (op[1] & 0x00)
4210         {
4211           case 0x00:
4212             goto op_semantics_26;
4213             break;
4214         }
4215       break;
4216     case 0x56:
4217         GETBYTE ();
4218         switch (op[1] & 0x00)
4219         {
4220           case 0x00:
4221             goto op_semantics_26;
4222             break;
4223         }
4224       break;
4225     case 0x57:
4226         GETBYTE ();
4227         switch (op[1] & 0x00)
4228         {
4229           case 0x00:
4230             goto op_semantics_26;
4231             break;
4232         }
4233       break;
4234     case 0x58:
4235         GETBYTE ();
4236         switch (op[1] & 0x00)
4237         {
4238           case 0x00:
4239             op_semantics_27:
4240               {
4241                 /** 0101 1 s ss rsrc rdst       movu%s  %1, %0 */
4242 #line 359 "rx-decode.opc"
4243                 int s AU = (op[0] >> 2) & 0x01;
4244 #line 359 "rx-decode.opc"
4245                 int ss AU = op[0] & 0x03;
4246 #line 359 "rx-decode.opc"
4247                 int rsrc AU = (op[1] >> 4) & 0x0f;
4248 #line 359 "rx-decode.opc"
4249                 int rdst AU = op[1] & 0x0f;
4250                 if (trace)
4251                   {
4252                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4253                            "/** 0101 1 s ss rsrc rdst   movu%s  %1, %0 */",
4254                            op[0], op[1]);
4255                     printf ("  s = 0x%x,", s);
4256                     printf ("  ss = 0x%x,", ss);
4257                     printf ("  rsrc = 0x%x,", rsrc);
4258                     printf ("  rdst = 0x%x\n", rdst);
4259                   }
4260                 SYNTAX("movu%s  %1, %0");
4261 #line 359 "rx-decode.opc"
4262                 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
4263
4264               }
4265             break;
4266         }
4267       break;
4268     case 0x59:
4269         GETBYTE ();
4270         switch (op[1] & 0x00)
4271         {
4272           case 0x00:
4273             goto op_semantics_27;
4274             break;
4275         }
4276       break;
4277     case 0x5a:
4278         GETBYTE ();
4279         switch (op[1] & 0x00)
4280         {
4281           case 0x00:
4282             goto op_semantics_27;
4283             break;
4284         }
4285       break;
4286     case 0x5b:
4287         GETBYTE ();
4288         switch (op[1] & 0x00)
4289         {
4290           case 0x00:
4291             goto op_semantics_27;
4292             break;
4293         }
4294       break;
4295     case 0x5c:
4296         GETBYTE ();
4297         switch (op[1] & 0x00)
4298         {
4299           case 0x00:
4300             goto op_semantics_27;
4301             break;
4302         }
4303       break;
4304     case 0x5d:
4305         GETBYTE ();
4306         switch (op[1] & 0x00)
4307         {
4308           case 0x00:
4309             goto op_semantics_27;
4310             break;
4311         }
4312       break;
4313     case 0x5e:
4314         GETBYTE ();
4315         switch (op[1] & 0x00)
4316         {
4317           case 0x00:
4318             goto op_semantics_27;
4319             break;
4320         }
4321       break;
4322     case 0x5f:
4323         GETBYTE ();
4324         switch (op[1] & 0x00)
4325         {
4326           case 0x00:
4327             goto op_semantics_27;
4328             break;
4329         }
4330       break;
4331     case 0x60:
4332         GETBYTE ();
4333         switch (op[1] & 0x00)
4334         {
4335           case 0x00:
4336               {
4337                 /** 0110 0000 immm rdst                 sub     #%2, %0 */
4338 #line 540 "rx-decode.opc"
4339                 int immm AU = (op[1] >> 4) & 0x0f;
4340 #line 540 "rx-decode.opc"
4341                 int rdst AU = op[1] & 0x0f;
4342                 if (trace)
4343                   {
4344                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4345                            "/** 0110 0000 immm rdst                     sub     #%2, %0 */",
4346                            op[0], op[1]);
4347                     printf ("  immm = 0x%x,", immm);
4348                     printf ("  rdst = 0x%x\n", rdst);
4349                   }
4350                 SYNTAX("sub     #%2, %0");
4351 #line 540 "rx-decode.opc"
4352                 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4353
4354               }
4355             break;
4356         }
4357       break;
4358     case 0x61:
4359         GETBYTE ();
4360         switch (op[1] & 0x00)
4361         {
4362           case 0x00:
4363               {
4364                 /** 0110 0001 immm rdst                 cmp     #%2, %1 */
4365 #line 522 "rx-decode.opc"
4366                 int immm AU = (op[1] >> 4) & 0x0f;
4367 #line 522 "rx-decode.opc"
4368                 int rdst AU = op[1] & 0x0f;
4369                 if (trace)
4370                   {
4371                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4372                            "/** 0110 0001 immm rdst                     cmp     #%2, %1 */",
4373                            op[0], op[1]);
4374                     printf ("  immm = 0x%x,", immm);
4375                     printf ("  rdst = 0x%x\n", rdst);
4376                   }
4377                 SYNTAX("cmp     #%2, %1");
4378 #line 522 "rx-decode.opc"
4379                 ID(sub); S2C(immm); SR(rdst); F_OSZC;
4380
4381               }
4382             break;
4383         }
4384       break;
4385     case 0x62:
4386         GETBYTE ();
4387         switch (op[1] & 0x00)
4388         {
4389           case 0x00:
4390               {
4391                 /** 0110 0010 immm rdst                 add     #%1, %0 */
4392 #line 504 "rx-decode.opc"
4393                 int immm AU = (op[1] >> 4) & 0x0f;
4394 #line 504 "rx-decode.opc"
4395                 int rdst AU = op[1] & 0x0f;
4396                 if (trace)
4397                   {
4398                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4399                            "/** 0110 0010 immm rdst                     add     #%1, %0 */",
4400                            op[0], op[1]);
4401                     printf ("  immm = 0x%x,", immm);
4402                     printf ("  rdst = 0x%x\n", rdst);
4403                   }
4404                 SYNTAX("add     #%1, %0");
4405 #line 504 "rx-decode.opc"
4406                 ID(add); SC(immm); DR(rdst); F_OSZC;
4407
4408               }
4409             break;
4410         }
4411       break;
4412     case 0x63:
4413         GETBYTE ();
4414         switch (op[1] & 0x00)
4415         {
4416           case 0x00:
4417               {
4418                 /** 0110 0011 immm rdst                 mul     #%1, %0 */
4419 #line 616 "rx-decode.opc"
4420                 int immm AU = (op[1] >> 4) & 0x0f;
4421 #line 616 "rx-decode.opc"
4422                 int rdst AU = op[1] & 0x0f;
4423                 if (trace)
4424                   {
4425                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4426                            "/** 0110 0011 immm rdst                     mul     #%1, %0 */",
4427                            op[0], op[1]);
4428                     printf ("  immm = 0x%x,", immm);
4429                     printf ("  rdst = 0x%x\n", rdst);
4430                   }
4431                 SYNTAX("mul     #%1, %0");
4432 #line 616 "rx-decode.opc"
4433                 if (immm == 1 && rdst == 0)
4434                   {
4435                     ID(nop2);
4436                     SYNTAX ("nop\t; mul\t#1, r0");
4437                   }
4438                 else
4439                   {
4440                     ID(mul);
4441                   }
4442                 DR(rdst); SC(immm); F_____;
4443
4444               }
4445             break;
4446         }
4447       break;
4448     case 0x64:
4449         GETBYTE ();
4450         switch (op[1] & 0x00)
4451         {
4452           case 0x00:
4453               {
4454                 /** 0110 0100 immm rdst                 and     #%1, %0 */
4455 #line 414 "rx-decode.opc"
4456                 int immm AU = (op[1] >> 4) & 0x0f;
4457 #line 414 "rx-decode.opc"
4458                 int rdst AU = op[1] & 0x0f;
4459                 if (trace)
4460                   {
4461                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4462                            "/** 0110 0100 immm rdst                     and     #%1, %0 */",
4463                            op[0], op[1]);
4464                     printf ("  immm = 0x%x,", immm);
4465                     printf ("  rdst = 0x%x\n", rdst);
4466                   }
4467                 SYNTAX("and     #%1, %0");
4468 #line 414 "rx-decode.opc"
4469                 ID(and); SC(immm); DR(rdst); F__SZ_;
4470
4471               }
4472             break;
4473         }
4474       break;
4475     case 0x65:
4476         GETBYTE ();
4477         switch (op[1] & 0x00)
4478         {
4479           case 0x00:
4480               {
4481                 /** 0110 0101 immm rdst                 or      #%1, %0 */
4482 #line 432 "rx-decode.opc"
4483                 int immm AU = (op[1] >> 4) & 0x0f;
4484 #line 432 "rx-decode.opc"
4485                 int rdst AU = op[1] & 0x0f;
4486                 if (trace)
4487                   {
4488                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4489                            "/** 0110 0101 immm rdst                     or      #%1, %0 */",
4490                            op[0], op[1]);
4491                     printf ("  immm = 0x%x,", immm);
4492                     printf ("  rdst = 0x%x\n", rdst);
4493                   }
4494                 SYNTAX("or      #%1, %0");
4495 #line 432 "rx-decode.opc"
4496                 ID(or); SC(immm); DR(rdst); F__SZ_;
4497
4498               }
4499             break;
4500         }
4501       break;
4502     case 0x66:
4503         GETBYTE ();
4504         switch (op[1] & 0x00)
4505         {
4506           case 0x00:
4507               {
4508                 /** 0110 0110 immm rdst         mov%s   #%1, %0 */
4509 #line 308 "rx-decode.opc"
4510                 int immm AU = (op[1] >> 4) & 0x0f;
4511 #line 308 "rx-decode.opc"
4512                 int rdst AU = op[1] & 0x0f;
4513                 if (trace)
4514                   {
4515                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4516                            "/** 0110 0110 immm rdst             mov%s   #%1, %0 */",
4517                            op[0], op[1]);
4518                     printf ("  immm = 0x%x,", immm);
4519                     printf ("  rdst = 0x%x\n", rdst);
4520                   }
4521                 SYNTAX("mov%s   #%1, %0");
4522 #line 308 "rx-decode.opc"
4523                 ID(mov); DR(rdst); SC(immm); F_____;
4524
4525               }
4526             break;
4527         }
4528       break;
4529     case 0x67:
4530         {
4531           /** 0110 0111                 rtsd    #%1 */
4532           if (trace)
4533             {
4534               printf ("\033[33m%s\033[0m  %02x\n",
4535                      "/** 0110 0111                     rtsd    #%1 */",
4536                      op[0]);
4537             }
4538           SYNTAX("rtsd  #%1");
4539 #line 405 "rx-decode.opc"
4540           ID(rtsd); SC(IMM(1) * 4);
4541
4542         }
4543       break;
4544     case 0x68:
4545         GETBYTE ();
4546         switch (op[1] & 0x00)
4547         {
4548           case 0x00:
4549             op_semantics_28:
4550               {
4551                 /** 0110 100i mmmm rdst                 shlr    #%2, %0 */
4552 #line 730 "rx-decode.opc"
4553                 int i AU = op[0] & 0x01;
4554 #line 730 "rx-decode.opc"
4555                 int mmmm AU = (op[1] >> 4) & 0x0f;
4556 #line 730 "rx-decode.opc"
4557                 int rdst AU = op[1] & 0x0f;
4558                 if (trace)
4559                   {
4560                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4561                            "/** 0110 100i mmmm rdst                     shlr    #%2, %0 */",
4562                            op[0], op[1]);
4563                     printf ("  i = 0x%x,", i);
4564                     printf ("  mmmm = 0x%x,", mmmm);
4565                     printf ("  rdst = 0x%x\n", rdst);
4566                   }
4567                 SYNTAX("shlr    #%2, %0");
4568 #line 730 "rx-decode.opc"
4569                 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4570
4571               }
4572             break;
4573         }
4574       break;
4575     case 0x69:
4576         GETBYTE ();
4577         switch (op[1] & 0x00)
4578         {
4579           case 0x00:
4580             goto op_semantics_28;
4581             break;
4582         }
4583       break;
4584     case 0x6a:
4585         GETBYTE ();
4586         switch (op[1] & 0x00)
4587         {
4588           case 0x00:
4589             op_semantics_29:
4590               {
4591                 /** 0110 101i mmmm rdst                 shar    #%2, %0 */
4592 #line 720 "rx-decode.opc"
4593                 int i AU = op[0] & 0x01;
4594 #line 720 "rx-decode.opc"
4595                 int mmmm AU = (op[1] >> 4) & 0x0f;
4596 #line 720 "rx-decode.opc"
4597                 int rdst AU = op[1] & 0x0f;
4598                 if (trace)
4599                   {
4600                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4601                            "/** 0110 101i mmmm rdst                     shar    #%2, %0 */",
4602                            op[0], op[1]);
4603                     printf ("  i = 0x%x,", i);
4604                     printf ("  mmmm = 0x%x,", mmmm);
4605                     printf ("  rdst = 0x%x\n", rdst);
4606                   }
4607                 SYNTAX("shar    #%2, %0");
4608 #line 720 "rx-decode.opc"
4609                 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4610
4611               }
4612             break;
4613         }
4614       break;
4615     case 0x6b:
4616         GETBYTE ();
4617         switch (op[1] & 0x00)
4618         {
4619           case 0x00:
4620             goto op_semantics_29;
4621             break;
4622         }
4623       break;
4624     case 0x6c:
4625         GETBYTE ();
4626         switch (op[1] & 0x00)
4627         {
4628           case 0x00:
4629             op_semantics_30:
4630               {
4631                 /** 0110 110i mmmm rdst                 shll    #%2, %0 */
4632 #line 710 "rx-decode.opc"
4633                 int i AU = op[0] & 0x01;
4634 #line 710 "rx-decode.opc"
4635                 int mmmm AU = (op[1] >> 4) & 0x0f;
4636 #line 710 "rx-decode.opc"
4637                 int rdst AU = op[1] & 0x0f;
4638                 if (trace)
4639                   {
4640                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4641                            "/** 0110 110i mmmm rdst                     shll    #%2, %0 */",
4642                            op[0], op[1]);
4643                     printf ("  i = 0x%x,", i);
4644                     printf ("  mmmm = 0x%x,", mmmm);
4645                     printf ("  rdst = 0x%x\n", rdst);
4646                   }
4647                 SYNTAX("shll    #%2, %0");
4648 #line 710 "rx-decode.opc"
4649                 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4650
4651               }
4652             break;
4653         }
4654       break;
4655     case 0x6d:
4656         GETBYTE ();
4657         switch (op[1] & 0x00)
4658         {
4659           case 0x00:
4660             goto op_semantics_30;
4661             break;
4662         }
4663       break;
4664     case 0x6e:
4665         GETBYTE ();
4666         switch (op[1] & 0x00)
4667         {
4668           case 0x00:
4669               {
4670                 /** 0110 1110 dsta dstb         pushm   %1-%2 */
4671 #line 372 "rx-decode.opc"
4672                 int dsta AU = (op[1] >> 4) & 0x0f;
4673 #line 372 "rx-decode.opc"
4674                 int dstb AU = op[1] & 0x0f;
4675                 if (trace)
4676                   {
4677                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4678                            "/** 0110 1110 dsta dstb             pushm   %1-%2 */",
4679                            op[0], op[1]);
4680                     printf ("  dsta = 0x%x,", dsta);
4681                     printf ("  dstb = 0x%x\n", dstb);
4682                   }
4683                 SYNTAX("pushm   %1-%2");
4684 #line 372 "rx-decode.opc"
4685                 ID(pushm); SR(dsta); S2R(dstb); F_____;
4686
4687               }
4688             break;
4689         }
4690       break;
4691     case 0x6f:
4692         GETBYTE ();
4693         switch (op[1] & 0x00)
4694         {
4695           case 0x00:
4696               {
4697                 /** 0110 1111 dsta dstb         popm    %1-%2 */
4698 #line 369 "rx-decode.opc"
4699                 int dsta AU = (op[1] >> 4) & 0x0f;
4700 #line 369 "rx-decode.opc"
4701                 int dstb AU = op[1] & 0x0f;
4702                 if (trace)
4703                   {
4704                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4705                            "/** 0110 1111 dsta dstb             popm    %1-%2 */",
4706                            op[0], op[1]);
4707                     printf ("  dsta = 0x%x,", dsta);
4708                     printf ("  dstb = 0x%x\n", dstb);
4709                   }
4710                 SYNTAX("popm    %1-%2");
4711 #line 369 "rx-decode.opc"
4712                 ID(popm); SR(dsta); S2R(dstb); F_____;
4713
4714               }
4715             break;
4716         }
4717       break;
4718     case 0x70:
4719         GETBYTE ();
4720         switch (op[1] & 0x00)
4721         {
4722           case 0x00:
4723             op_semantics_31:
4724               {
4725                 /** 0111 00im rsrc rdst                 add     #%1, %2, %0 */
4726 #line 513 "rx-decode.opc"
4727                 int im AU = op[0] & 0x03;
4728 #line 513 "rx-decode.opc"
4729                 int rsrc AU = (op[1] >> 4) & 0x0f;
4730 #line 513 "rx-decode.opc"
4731                 int rdst AU = op[1] & 0x0f;
4732                 if (trace)
4733                   {
4734                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4735                            "/** 0111 00im rsrc rdst                     add     #%1, %2, %0 */",
4736                            op[0], op[1]);
4737                     printf ("  im = 0x%x,", im);
4738                     printf ("  rsrc = 0x%x,", rsrc);
4739                     printf ("  rdst = 0x%x\n", rdst);
4740                   }
4741                 SYNTAX("add     #%1, %2, %0");
4742 #line 513 "rx-decode.opc"
4743                 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4744
4745               }
4746             break;
4747         }
4748       break;
4749     case 0x71:
4750         GETBYTE ();
4751         switch (op[1] & 0x00)
4752         {
4753           case 0x00:
4754             goto op_semantics_31;
4755             break;
4756         }
4757       break;
4758     case 0x72:
4759         GETBYTE ();
4760         switch (op[1] & 0x00)
4761         {
4762           case 0x00:
4763             goto op_semantics_31;
4764             break;
4765         }
4766       break;
4767     case 0x73:
4768         GETBYTE ();
4769         switch (op[1] & 0x00)
4770         {
4771           case 0x00:
4772             goto op_semantics_31;
4773             break;
4774         }
4775       break;
4776     case 0x74:
4777         GETBYTE ();
4778         switch (op[1] & 0xf0)
4779         {
4780           case 0x00:
4781             op_semantics_32:
4782               {
4783                 /** 0111 01im 0000 rsrc         cmp     #%2, %1%S1 */
4784 #line 525 "rx-decode.opc"
4785                 int im AU = op[0] & 0x03;
4786 #line 525 "rx-decode.opc"
4787                 int rsrc AU = op[1] & 0x0f;
4788                 if (trace)
4789                   {
4790                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4791                            "/** 0111 01im 0000 rsrc             cmp     #%2, %1%S1 */",
4792                            op[0], op[1]);
4793                     printf ("  im = 0x%x,", im);
4794                     printf ("  rsrc = 0x%x\n", rsrc);
4795                   }
4796                 SYNTAX("cmp     #%2, %1%S1");
4797 #line 525 "rx-decode.opc"
4798                 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4799
4800               }
4801             break;
4802           case 0x10:
4803             op_semantics_33:
4804               {
4805                 /** 0111 01im 0001rdst                  mul     #%1, %0 */
4806 #line 628 "rx-decode.opc"
4807                 int im AU = op[0] & 0x03;
4808 #line 628 "rx-decode.opc"
4809                 int rdst AU = op[1] & 0x0f;
4810                 if (trace)
4811                   {
4812                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4813                            "/** 0111 01im 0001rdst                      mul     #%1, %0 */",
4814                            op[0], op[1]);
4815                     printf ("  im = 0x%x,", im);
4816                     printf ("  rdst = 0x%x\n", rdst);
4817                   }
4818                 SYNTAX("mul     #%1, %0");
4819 #line 628 "rx-decode.opc"
4820                 int val = IMMex(im);
4821                 if (val == 1 && rdst == 0)
4822                   {
4823                     SYNTAX("nop\t; mul\t#1, r0");
4824                     switch (im)
4825                 {
4826                 case 2: ID(nop4); break;
4827                 case 3: ID(nop5); break;
4828                 case 0: ID(nop6); break;
4829                 default:
4830                   ID(mul);
4831                   SYNTAX("mul   #%1, %0");
4832                   break;
4833                 }
4834                   }
4835                 else
4836                   {
4837                     ID(mul);
4838                   }
4839                 DR(rdst); SC(val); F_____;
4840
4841               }
4842             break;
4843           case 0x20:
4844             op_semantics_34:
4845               {
4846                 /** 0111 01im 0010 rdst                 and     #%1, %0 */
4847 #line 417 "rx-decode.opc"
4848                 int im AU = op[0] & 0x03;
4849 #line 417 "rx-decode.opc"
4850                 int rdst AU = op[1] & 0x0f;
4851                 if (trace)
4852                   {
4853                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4854                            "/** 0111 01im 0010 rdst                     and     #%1, %0 */",
4855                            op[0], op[1]);
4856                     printf ("  im = 0x%x,", im);
4857                     printf ("  rdst = 0x%x\n", rdst);
4858                   }
4859                 SYNTAX("and     #%1, %0");
4860 #line 417 "rx-decode.opc"
4861                 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4862
4863               }
4864             break;
4865           case 0x30:
4866             op_semantics_35:
4867               {
4868                 /** 0111 01im 0011 rdst                 or      #%1, %0 */
4869 #line 435 "rx-decode.opc"
4870                 int im AU = op[0] & 0x03;
4871 #line 435 "rx-decode.opc"
4872                 int rdst AU = op[1] & 0x0f;
4873                 if (trace)
4874                   {
4875                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4876                            "/** 0111 01im 0011 rdst                     or      #%1, %0 */",
4877                            op[0], op[1]);
4878                     printf ("  im = 0x%x,", im);
4879                     printf ("  rdst = 0x%x\n", rdst);
4880                   }
4881                 SYNTAX("or      #%1, %0");
4882 #line 435 "rx-decode.opc"
4883                 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4884
4885               }
4886             break;
4887           default: UNSUPPORTED(); break;
4888         }
4889       break;
4890     case 0x75:
4891         GETBYTE ();
4892         switch (op[1] & 0xff)
4893         {
4894           case 0x00:
4895           case 0x01:
4896           case 0x02:
4897           case 0x03:
4898           case 0x04:
4899           case 0x05:
4900           case 0x06:
4901           case 0x07:
4902           case 0x08:
4903           case 0x09:
4904           case 0x0a:
4905           case 0x0b:
4906           case 0x0c:
4907           case 0x0d:
4908           case 0x0e:
4909           case 0x0f:
4910             goto op_semantics_32;
4911             break;
4912           case 0x10:
4913           case 0x11:
4914           case 0x12:
4915           case 0x13:
4916           case 0x14:
4917           case 0x15:
4918           case 0x16:
4919           case 0x17:
4920           case 0x18:
4921           case 0x19:
4922           case 0x1a:
4923           case 0x1b:
4924           case 0x1c:
4925           case 0x1d:
4926           case 0x1e:
4927           case 0x1f:
4928             goto op_semantics_33;
4929             break;
4930           case 0x20:
4931           case 0x21:
4932           case 0x22:
4933           case 0x23:
4934           case 0x24:
4935           case 0x25:
4936           case 0x26:
4937           case 0x27:
4938           case 0x28:
4939           case 0x29:
4940           case 0x2a:
4941           case 0x2b:
4942           case 0x2c:
4943           case 0x2d:
4944           case 0x2e:
4945           case 0x2f:
4946             goto op_semantics_34;
4947             break;
4948           case 0x30:
4949           case 0x31:
4950           case 0x32:
4951           case 0x33:
4952           case 0x34:
4953           case 0x35:
4954           case 0x36:
4955           case 0x37:
4956           case 0x38:
4957           case 0x39:
4958           case 0x3a:
4959           case 0x3b:
4960           case 0x3c:
4961           case 0x3d:
4962           case 0x3e:
4963           case 0x3f:
4964             goto op_semantics_35;
4965             break;
4966           case 0x40:
4967           case 0x41:
4968           case 0x42:
4969           case 0x43:
4970           case 0x44:
4971           case 0x45:
4972           case 0x46:
4973           case 0x47:
4974           case 0x48:
4975           case 0x49:
4976           case 0x4a:
4977           case 0x4b:
4978           case 0x4c:
4979           case 0x4d:
4980           case 0x4e:
4981           case 0x4f:
4982               {
4983                 /** 0111 0101 0100 rdst         mov%s   #%1, %0 */
4984 #line 289 "rx-decode.opc"
4985                 int rdst AU = op[1] & 0x0f;
4986                 if (trace)
4987                   {
4988                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4989                            "/** 0111 0101 0100 rdst             mov%s   #%1, %0 */",
4990                            op[0], op[1]);
4991                     printf ("  rdst = 0x%x\n", rdst);
4992                   }
4993                 SYNTAX("mov%s   #%1, %0");
4994 #line 289 "rx-decode.opc"
4995                 ID(mov); DR(rdst); SC(IMM (1)); F_____;
4996
4997               }
4998             break;
4999           case 0x50:
5000           case 0x51:
5001           case 0x52:
5002           case 0x53:
5003           case 0x54:
5004           case 0x55:
5005           case 0x56:
5006           case 0x57:
5007           case 0x58:
5008           case 0x59:
5009           case 0x5a:
5010           case 0x5b:
5011           case 0x5c:
5012           case 0x5d:
5013           case 0x5e:
5014           case 0x5f:
5015               {
5016                 /** 0111 0101 0101 rsrc                 cmp     #%2, %1 */
5017 #line 528 "rx-decode.opc"
5018                 int rsrc AU = op[1] & 0x0f;
5019                 if (trace)
5020                   {
5021                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5022                            "/** 0111 0101 0101 rsrc                     cmp     #%2, %1 */",
5023                            op[0], op[1]);
5024                     printf ("  rsrc = 0x%x\n", rsrc);
5025                   }
5026                 SYNTAX("cmp     #%2, %1");
5027 #line 528 "rx-decode.opc"
5028                 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
5029
5030               }
5031             break;
5032           case 0x60:
5033               {
5034                 /** 0111 0101 0110 0000         int #%1 */
5035                 if (trace)
5036                   {
5037                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5038                            "/** 0111 0101 0110 0000             int #%1 */",
5039                            op[0], op[1]);
5040                   }
5041                 SYNTAX("int #%1");
5042 #line 1035 "rx-decode.opc"
5043                 ID(int); SC(IMM(1));
5044
5045               }
5046             break;
5047           case 0x70:
5048               GETBYTE ();
5049               switch (op[2] & 0xf0)
5050               {
5051                 case 0x00:
5052                     {
5053                       /** 0111 0101 0111 0000 0000 immm mvtipl  #%1 */
5054 #line 1002 "rx-decode.opc"
5055                       int immm AU = op[2] & 0x0f;
5056                       if (trace)
5057                         {
5058                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5059                                  "/** 0111 0101 0111 0000 0000 immm     mvtipl  #%1 */",
5060                                  op[0], op[1], op[2]);
5061                           printf ("  immm = 0x%x\n", immm);
5062                         }
5063                       SYNTAX("mvtipl    #%1");
5064 #line 1002 "rx-decode.opc"
5065                       ID(mvtipl); SC(immm);
5066
5067                     }
5068                   break;
5069                 default: UNSUPPORTED(); break;
5070               }
5071             break;
5072           default: UNSUPPORTED(); break;
5073         }
5074       break;
5075     case 0x76:
5076         GETBYTE ();
5077         switch (op[1] & 0xf0)
5078         {
5079           case 0x00:
5080             goto op_semantics_32;
5081             break;
5082           case 0x10:
5083             goto op_semantics_33;
5084             break;
5085           case 0x20:
5086             goto op_semantics_34;
5087             break;
5088           case 0x30:
5089             goto op_semantics_35;
5090             break;
5091           default: UNSUPPORTED(); break;
5092         }
5093       break;
5094     case 0x77:
5095         GETBYTE ();
5096         switch (op[1] & 0xf0)
5097         {
5098           case 0x00:
5099             goto op_semantics_32;
5100             break;
5101           case 0x10:
5102             goto op_semantics_33;
5103             break;
5104           case 0x20:
5105             goto op_semantics_34;
5106             break;
5107           case 0x30:
5108             goto op_semantics_35;
5109             break;
5110           default: UNSUPPORTED(); break;
5111         }
5112       break;
5113     case 0x78:
5114         GETBYTE ();
5115         switch (op[1] & 0x00)
5116         {
5117           case 0x00:
5118             op_semantics_36:
5119               {
5120                 /** 0111 100b ittt rdst                 bset    #%1, %0 */
5121 #line 947 "rx-decode.opc"
5122                 int b AU = op[0] & 0x01;
5123 #line 947 "rx-decode.opc"
5124                 int ittt AU = (op[1] >> 4) & 0x0f;
5125 #line 947 "rx-decode.opc"
5126                 int rdst AU = op[1] & 0x0f;
5127                 if (trace)
5128                   {
5129                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5130                            "/** 0111 100b ittt rdst                     bset    #%1, %0 */",
5131                            op[0], op[1]);
5132                     printf ("  b = 0x%x,", b);
5133                     printf ("  ittt = 0x%x,", ittt);
5134                     printf ("  rdst = 0x%x\n", rdst);
5135                   }
5136                 SYNTAX("bset    #%1, %0");
5137 #line 947 "rx-decode.opc"
5138                 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5139
5140
5141               }
5142             break;
5143         }
5144       break;
5145     case 0x79:
5146         GETBYTE ();
5147         switch (op[1] & 0x00)
5148         {
5149           case 0x00:
5150             goto op_semantics_36;
5151             break;
5152         }
5153       break;
5154     case 0x7a:
5155         GETBYTE ();
5156         switch (op[1] & 0x00)
5157         {
5158           case 0x00:
5159             op_semantics_37:
5160               {
5161                 /** 0111 101b ittt rdst                 bclr    #%1, %0 */
5162 #line 959 "rx-decode.opc"
5163                 int b AU = op[0] & 0x01;
5164 #line 959 "rx-decode.opc"
5165                 int ittt AU = (op[1] >> 4) & 0x0f;
5166 #line 959 "rx-decode.opc"
5167                 int rdst AU = op[1] & 0x0f;
5168                 if (trace)
5169                   {
5170                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5171                            "/** 0111 101b ittt rdst                     bclr    #%1, %0 */",
5172                            op[0], op[1]);
5173                     printf ("  b = 0x%x,", b);
5174                     printf ("  ittt = 0x%x,", ittt);
5175                     printf ("  rdst = 0x%x\n", rdst);
5176                   }
5177                 SYNTAX("bclr    #%1, %0");
5178 #line 959 "rx-decode.opc"
5179                 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5180
5181
5182               }
5183             break;
5184         }
5185       break;
5186     case 0x7b:
5187         GETBYTE ();
5188         switch (op[1] & 0x00)
5189         {
5190           case 0x00:
5191             goto op_semantics_37;
5192             break;
5193         }
5194       break;
5195     case 0x7c:
5196         GETBYTE ();
5197         switch (op[1] & 0x00)
5198         {
5199           case 0x00:
5200             op_semantics_38:
5201               {
5202                 /** 0111 110b ittt rdst                 btst    #%2, %1 */
5203 #line 971 "rx-decode.opc"
5204                 int b AU = op[0] & 0x01;
5205 #line 971 "rx-decode.opc"
5206                 int ittt AU = (op[1] >> 4) & 0x0f;
5207 #line 971 "rx-decode.opc"
5208                 int rdst AU = op[1] & 0x0f;
5209                 if (trace)
5210                   {
5211                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5212                            "/** 0111 110b ittt rdst                     btst    #%2, %1 */",
5213                            op[0], op[1]);
5214                     printf ("  b = 0x%x,", b);
5215                     printf ("  ittt = 0x%x,", ittt);
5216                     printf ("  rdst = 0x%x\n", rdst);
5217                   }
5218                 SYNTAX("btst    #%2, %1");
5219 #line 971 "rx-decode.opc"
5220                 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
5221
5222
5223               }
5224             break;
5225         }
5226       break;
5227     case 0x7d:
5228         GETBYTE ();
5229         switch (op[1] & 0x00)
5230         {
5231           case 0x00:
5232             goto op_semantics_38;
5233             break;
5234         }
5235       break;
5236     case 0x7e:
5237         GETBYTE ();
5238         switch (op[1] & 0xf0)
5239         {
5240           case 0x00:
5241               {
5242                 /** 0111 1110 0000 rdst                 not     %0 */
5243 #line 462 "rx-decode.opc"
5244                 int rdst AU = op[1] & 0x0f;
5245                 if (trace)
5246                   {
5247                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5248                            "/** 0111 1110 0000 rdst                     not     %0 */",
5249                            op[0], op[1]);
5250                     printf ("  rdst = 0x%x\n", rdst);
5251                   }
5252                 SYNTAX("not     %0");
5253 #line 462 "rx-decode.opc"
5254                 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
5255
5256               }
5257             break;
5258           case 0x10:
5259               {
5260                 /** 0111 1110 0001 rdst                 neg     %0 */
5261 #line 483 "rx-decode.opc"
5262                 int rdst AU = op[1] & 0x0f;
5263                 if (trace)
5264                   {
5265                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5266                            "/** 0111 1110 0001 rdst                     neg     %0 */",
5267                            op[0], op[1]);
5268                     printf ("  rdst = 0x%x\n", rdst);
5269                   }
5270                 SYNTAX("neg     %0");
5271 #line 483 "rx-decode.opc"
5272                 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
5273
5274               }
5275             break;
5276           case 0x20:
5277               {
5278                 /** 0111 1110 0010 rdst                 abs     %0 */
5279 #line 565 "rx-decode.opc"
5280                 int rdst AU = op[1] & 0x0f;
5281                 if (trace)
5282                   {
5283                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5284                            "/** 0111 1110 0010 rdst                     abs     %0 */",
5285                            op[0], op[1]);
5286                     printf ("  rdst = 0x%x\n", rdst);
5287                   }
5288                 SYNTAX("abs     %0");
5289 #line 565 "rx-decode.opc"
5290                 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
5291
5292               }
5293             break;
5294           case 0x30:
5295               {
5296                 /** 0111 1110 0011 rdst         sat     %0 */
5297 #line 885 "rx-decode.opc"
5298                 int rdst AU = op[1] & 0x0f;
5299                 if (trace)
5300                   {
5301                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5302                            "/** 0111 1110 0011 rdst             sat     %0 */",
5303                            op[0], op[1]);
5304                     printf ("  rdst = 0x%x\n", rdst);
5305                   }
5306                 SYNTAX("sat     %0");
5307 #line 885 "rx-decode.opc"
5308                 ID(sat); DR (rdst);
5309
5310               }
5311             break;
5312           case 0x40:
5313               {
5314                 /** 0111 1110 0100 rdst                 rorc    %0 */
5315 #line 745 "rx-decode.opc"
5316                 int rdst AU = op[1] & 0x0f;
5317                 if (trace)
5318                   {
5319                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5320                            "/** 0111 1110 0100 rdst                     rorc    %0 */",
5321                            op[0], op[1]);
5322                     printf ("  rdst = 0x%x\n", rdst);
5323                   }
5324                 SYNTAX("rorc    %0");
5325 #line 745 "rx-decode.opc"
5326                 ID(rorc); DR(rdst); F__SZC;
5327
5328               }
5329             break;
5330           case 0x50:
5331               {
5332                 /** 0111 1110 0101 rdst                 rolc    %0 */
5333 #line 742 "rx-decode.opc"
5334                 int rdst AU = op[1] & 0x0f;
5335                 if (trace)
5336                   {
5337                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5338                            "/** 0111 1110 0101 rdst                     rolc    %0 */",
5339                            op[0], op[1]);
5340                     printf ("  rdst = 0x%x\n", rdst);
5341                   }
5342                 SYNTAX("rolc    %0");
5343 #line 742 "rx-decode.opc"
5344                 ID(rolc); DR(rdst); F__SZC;
5345
5346               }
5347             break;
5348           case 0x80:
5349           case 0x90:
5350           case 0xa0:
5351               {
5352                 /** 0111 1110 10sz rsrc         push%s  %1 */
5353 #line 378 "rx-decode.opc"
5354                 int sz AU = (op[1] >> 4) & 0x03;
5355 #line 378 "rx-decode.opc"
5356                 int rsrc AU = op[1] & 0x0f;
5357                 if (trace)
5358                   {
5359                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5360                            "/** 0111 1110 10sz rsrc             push%s  %1 */",
5361                            op[0], op[1]);
5362                     printf ("  sz = 0x%x,", sz);
5363                     printf ("  rsrc = 0x%x\n", rsrc);
5364                   }
5365                 SYNTAX("push%s  %1");
5366 #line 378 "rx-decode.opc"
5367                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
5368
5369               }
5370             break;
5371           case 0xb0:
5372               {
5373                 /** 0111 1110 1011 rdst         pop     %0 */
5374 #line 375 "rx-decode.opc"
5375                 int rdst AU = op[1] & 0x0f;
5376                 if (trace)
5377                   {
5378                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5379                            "/** 0111 1110 1011 rdst             pop     %0 */",
5380                            op[0], op[1]);
5381                     printf ("  rdst = 0x%x\n", rdst);
5382                   }
5383                 SYNTAX("pop     %0");
5384 #line 375 "rx-decode.opc"
5385                 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
5386
5387               }
5388             break;
5389           case 0xc0:
5390           case 0xd0:
5391               {
5392                 /** 0111 1110 110 crsrc                 pushc   %1 */
5393 #line 1008 "rx-decode.opc"
5394                 int crsrc AU = op[1] & 0x1f;
5395                 if (trace)
5396                   {
5397                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5398                            "/** 0111 1110 110 crsrc                     pushc   %1 */",
5399                            op[0], op[1]);
5400                     printf ("  crsrc = 0x%x\n", crsrc);
5401                   }
5402                 SYNTAX("pushc   %1");
5403 #line 1008 "rx-decode.opc"
5404                 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5405
5406               }
5407             break;
5408           case 0xe0:
5409           case 0xf0:
5410               {
5411                 /** 0111 1110 111 crdst                 popc    %0 */
5412 #line 1005 "rx-decode.opc"
5413                 int crdst AU = op[1] & 0x1f;
5414                 if (trace)
5415                   {
5416                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5417                            "/** 0111 1110 111 crdst                     popc    %0 */",
5418                            op[0], op[1]);
5419                     printf ("  crdst = 0x%x\n", crdst);
5420                   }
5421                 SYNTAX("popc    %0");
5422 #line 1005 "rx-decode.opc"
5423                 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5424
5425               }
5426             break;
5427           default: UNSUPPORTED(); break;
5428         }
5429       break;
5430     case 0x7f:
5431         GETBYTE ();
5432         switch (op[1] & 0xff)
5433         {
5434           case 0x00:
5435           case 0x01:
5436           case 0x02:
5437           case 0x03:
5438           case 0x04:
5439           case 0x05:
5440           case 0x06:
5441           case 0x07:
5442           case 0x08:
5443           case 0x09:
5444           case 0x0a:
5445           case 0x0b:
5446           case 0x0c:
5447           case 0x0d:
5448           case 0x0e:
5449           case 0x0f:
5450               {
5451                 /** 0111 1111 0000 rsrc         jmp     %0 */
5452 #line 795 "rx-decode.opc"
5453                 int rsrc AU = op[1] & 0x0f;
5454                 if (trace)
5455                   {
5456                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5457                            "/** 0111 1111 0000 rsrc             jmp     %0 */",
5458                            op[0], op[1]);
5459                     printf ("  rsrc = 0x%x\n", rsrc);
5460                   }
5461                 SYNTAX("jmp     %0");
5462 #line 795 "rx-decode.opc"
5463                 ID(branch); DR(rsrc);
5464
5465               }
5466             break;
5467           case 0x10:
5468           case 0x11:
5469           case 0x12:
5470           case 0x13:
5471           case 0x14:
5472           case 0x15:
5473           case 0x16:
5474           case 0x17:
5475           case 0x18:
5476           case 0x19:
5477           case 0x1a:
5478           case 0x1b:
5479           case 0x1c:
5480           case 0x1d:
5481           case 0x1e:
5482           case 0x1f:
5483               {
5484                 /** 0111 1111 0001 rsrc         jsr     %0 */
5485 #line 798 "rx-decode.opc"
5486                 int rsrc AU = op[1] & 0x0f;
5487                 if (trace)
5488                   {
5489                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5490                            "/** 0111 1111 0001 rsrc             jsr     %0 */",
5491                            op[0], op[1]);
5492                     printf ("  rsrc = 0x%x\n", rsrc);
5493                   }
5494                 SYNTAX("jsr     %0");
5495 #line 798 "rx-decode.opc"
5496                 ID(jsr); DR(rsrc);
5497
5498               }
5499             break;
5500           case 0x40:
5501           case 0x41:
5502           case 0x42:
5503           case 0x43:
5504           case 0x44:
5505           case 0x45:
5506           case 0x46:
5507           case 0x47:
5508           case 0x48:
5509           case 0x49:
5510           case 0x4a:
5511           case 0x4b:
5512           case 0x4c:
5513           case 0x4d:
5514           case 0x4e:
5515           case 0x4f:
5516               {
5517                 /** 0111 1111 0100 rsrc         bra.l   %0 */
5518 #line 791 "rx-decode.opc"
5519                 int rsrc AU = op[1] & 0x0f;
5520                 if (trace)
5521                   {
5522                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5523                            "/** 0111 1111 0100 rsrc             bra.l   %0 */",
5524                            op[0], op[1]);
5525                     printf ("  rsrc = 0x%x\n", rsrc);
5526                   }
5527                 SYNTAX("bra.l   %0");
5528 #line 791 "rx-decode.opc"
5529                 ID(branchrel); DR(rsrc);
5530
5531
5532               }
5533             break;
5534           case 0x50:
5535           case 0x51:
5536           case 0x52:
5537           case 0x53:
5538           case 0x54:
5539           case 0x55:
5540           case 0x56:
5541           case 0x57:
5542           case 0x58:
5543           case 0x59:
5544           case 0x5a:
5545           case 0x5b:
5546           case 0x5c:
5547           case 0x5d:
5548           case 0x5e:
5549           case 0x5f:
5550               {
5551                 /** 0111 1111 0101 rsrc         bsr.l   %0 */
5552 #line 807 "rx-decode.opc"
5553                 int rsrc AU = op[1] & 0x0f;
5554                 if (trace)
5555                   {
5556                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5557                            "/** 0111 1111 0101 rsrc             bsr.l   %0 */",
5558                            op[0], op[1]);
5559                     printf ("  rsrc = 0x%x\n", rsrc);
5560                   }
5561                 SYNTAX("bsr.l   %0");
5562 #line 807 "rx-decode.opc"
5563                 ID(jsrrel); DR(rsrc);
5564
5565               }
5566             break;
5567           case 0x80:
5568           case 0x81:
5569           case 0x82:
5570               {
5571                 /** 0111 1111 1000 00sz         suntil%s */
5572 #line 831 "rx-decode.opc"
5573                 int sz AU = op[1] & 0x03;
5574                 if (trace)
5575                   {
5576                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5577                            "/** 0111 1111 1000 00sz             suntil%s */",
5578                            op[0], op[1]);
5579                     printf ("  sz = 0x%x\n", sz);
5580                   }
5581                 SYNTAX("suntil%s");
5582 #line 831 "rx-decode.opc"
5583                 ID(suntil); BWL(sz); F___ZC;
5584
5585               }
5586             break;
5587           case 0x83:
5588               {
5589                 /** 0111 1111 1000 0011         scmpu */
5590                 if (trace)
5591                   {
5592                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5593                            "/** 0111 1111 1000 0011             scmpu */",
5594                            op[0], op[1]);
5595                   }
5596                 SYNTAX("scmpu");
5597 #line 822 "rx-decode.opc"
5598                 ID(scmpu); F___ZC;
5599
5600               }
5601             break;
5602           case 0x84:
5603           case 0x85:
5604           case 0x86:
5605               {
5606                 /** 0111 1111 1000 01sz         swhile%s */
5607 #line 834 "rx-decode.opc"
5608                 int sz AU = op[1] & 0x03;
5609                 if (trace)
5610                   {
5611                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5612                            "/** 0111 1111 1000 01sz             swhile%s */",
5613                            op[0], op[1]);
5614                     printf ("  sz = 0x%x\n", sz);
5615                   }
5616                 SYNTAX("swhile%s");
5617 #line 834 "rx-decode.opc"
5618                 ID(swhile); BWL(sz); F___ZC;
5619
5620               }
5621             break;
5622           case 0x87:
5623               {
5624                 /** 0111 1111 1000 0111         smovu */
5625                 if (trace)
5626                   {
5627                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5628                            "/** 0111 1111 1000 0111             smovu */",
5629                            op[0], op[1]);
5630                   }
5631                 SYNTAX("smovu");
5632 #line 825 "rx-decode.opc"
5633                 ID(smovu);
5634
5635               }
5636             break;
5637           case 0x88:
5638           case 0x89:
5639           case 0x8a:
5640               {
5641                 /** 0111 1111 1000 10sz         sstr%s */
5642 #line 840 "rx-decode.opc"
5643                 int sz AU = op[1] & 0x03;
5644                 if (trace)
5645                   {
5646                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5647                            "/** 0111 1111 1000 10sz             sstr%s */",
5648                            op[0], op[1]);
5649                     printf ("  sz = 0x%x\n", sz);
5650                   }
5651                 SYNTAX("sstr%s");
5652 #line 840 "rx-decode.opc"
5653                 ID(sstr); BWL(sz);
5654
5655               /*----------------------------------------------------------------------*/
5656               /* RMPA                                                                   */
5657
5658               }
5659             break;
5660           case 0x8b:
5661               {
5662                 /** 0111 1111 1000 1011         smovb */
5663                 if (trace)
5664                   {
5665                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5666                            "/** 0111 1111 1000 1011             smovb */",
5667                            op[0], op[1]);
5668                   }
5669                 SYNTAX("smovb");
5670 #line 828 "rx-decode.opc"
5671                 ID(smovb);
5672
5673               }
5674             break;
5675           case 0x8c:
5676           case 0x8d:
5677           case 0x8e:
5678               {
5679                 /** 0111 1111 1000 11sz         rmpa%s */
5680 #line 846 "rx-decode.opc"
5681                 int sz AU = op[1] & 0x03;
5682                 if (trace)
5683                   {
5684                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5685                            "/** 0111 1111 1000 11sz             rmpa%s */",
5686                            op[0], op[1]);
5687                     printf ("  sz = 0x%x\n", sz);
5688                   }
5689                 SYNTAX("rmpa%s");
5690 #line 846 "rx-decode.opc"
5691                 ID(rmpa); BWL(sz); F_OS__;
5692
5693               /*----------------------------------------------------------------------*/
5694               /* HI/LO stuff                                                            */
5695
5696               }
5697             break;
5698           case 0x8f:
5699               {
5700                 /** 0111 1111 1000 1111         smovf */
5701                 if (trace)
5702                   {
5703                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5704                            "/** 0111 1111 1000 1111             smovf */",
5705                            op[0], op[1]);
5706                   }
5707                 SYNTAX("smovf");
5708 #line 837 "rx-decode.opc"
5709                 ID(smovf);
5710
5711               }
5712             break;
5713           case 0x93:
5714               {
5715                 /** 0111 1111 1001 0011         satr */
5716                 if (trace)
5717                   {
5718                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5719                            "/** 0111 1111 1001 0011             satr */",
5720                            op[0], op[1]);
5721                   }
5722                 SYNTAX("satr");
5723 #line 888 "rx-decode.opc"
5724                 ID(satr);
5725
5726               /*----------------------------------------------------------------------*/
5727               /* FLOAT                                                          */
5728
5729               }
5730             break;
5731           case 0x94:
5732               {
5733                 /** 0111 1111 1001 0100         rtfi */
5734                 if (trace)
5735                   {
5736                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5737                            "/** 0111 1111 1001 0100             rtfi */",
5738                            op[0], op[1]);
5739                   }
5740                 SYNTAX("rtfi");
5741 #line 1023 "rx-decode.opc"
5742                 ID(rtfi);
5743
5744               }
5745             break;
5746           case 0x95:
5747               {
5748                 /** 0111 1111 1001 0101         rte */
5749                 if (trace)
5750                   {
5751                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5752                            "/** 0111 1111 1001 0101             rte */",
5753                            op[0], op[1]);
5754                   }
5755                 SYNTAX("rte");
5756 #line 1026 "rx-decode.opc"
5757                 ID(rte);
5758
5759               }
5760             break;
5761           case 0x96:
5762               {
5763                 /** 0111 1111 1001 0110         wait */
5764                 if (trace)
5765                   {
5766                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5767                            "/** 0111 1111 1001 0110             wait */",
5768                            op[0], op[1]);
5769                   }
5770                 SYNTAX("wait");
5771 #line 1038 "rx-decode.opc"
5772                 ID(wait);
5773
5774               /*----------------------------------------------------------------------*/
5775               /* SCcnd                                                          */
5776
5777               }
5778             break;
5779           case 0xa0:
5780           case 0xa1:
5781           case 0xa2:
5782           case 0xa3:
5783           case 0xa4:
5784           case 0xa5:
5785           case 0xa6:
5786           case 0xa7:
5787           case 0xa8:
5788           case 0xa9:
5789           case 0xaa:
5790           case 0xab:
5791           case 0xac:
5792           case 0xad:
5793           case 0xae:
5794           case 0xaf:
5795               {
5796                 /** 0111 1111 1010 rdst                 setpsw  %0 */
5797 #line 999 "rx-decode.opc"
5798                 int rdst AU = op[1] & 0x0f;
5799                 if (trace)
5800                   {
5801                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5802                            "/** 0111 1111 1010 rdst                     setpsw  %0 */",
5803                            op[0], op[1]);
5804                     printf ("  rdst = 0x%x\n", rdst);
5805                   }
5806                 SYNTAX("setpsw  %0");
5807 #line 999 "rx-decode.opc"
5808                 ID(setpsw); DF(rdst);
5809
5810               }
5811             break;
5812           case 0xb0:
5813           case 0xb1:
5814           case 0xb2:
5815           case 0xb3:
5816           case 0xb4:
5817           case 0xb5:
5818           case 0xb6:
5819           case 0xb7:
5820           case 0xb8:
5821           case 0xb9:
5822           case 0xba:
5823           case 0xbb:
5824           case 0xbc:
5825           case 0xbd:
5826           case 0xbe:
5827           case 0xbf:
5828               {
5829                 /** 0111 1111 1011 rdst                 clrpsw  %0 */
5830 #line 996 "rx-decode.opc"
5831                 int rdst AU = op[1] & 0x0f;
5832                 if (trace)
5833                   {
5834                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5835                            "/** 0111 1111 1011 rdst                     clrpsw  %0 */",
5836                            op[0], op[1]);
5837                     printf ("  rdst = 0x%x\n", rdst);
5838                   }
5839                 SYNTAX("clrpsw  %0");
5840 #line 996 "rx-decode.opc"
5841                 ID(clrpsw); DF(rdst);
5842
5843               }
5844             break;
5845           default: UNSUPPORTED(); break;
5846         }
5847       break;
5848     case 0x80:
5849         GETBYTE ();
5850         switch (op[1] & 0x00)
5851         {
5852           case 0x00:
5853             op_semantics_39:
5854               {
5855                 /** 10sz 0dsp a dst b src       mov%s   %1, %0 */
5856 #line 336 "rx-decode.opc"
5857                 int sz AU = (op[0] >> 4) & 0x03;
5858 #line 336 "rx-decode.opc"
5859                 int dsp AU = op[0] & 0x07;
5860 #line 336 "rx-decode.opc"
5861                 int a AU = (op[1] >> 7) & 0x01;
5862 #line 336 "rx-decode.opc"
5863                 int dst AU = (op[1] >> 4) & 0x07;
5864 #line 336 "rx-decode.opc"
5865                 int b AU = (op[1] >> 3) & 0x01;
5866 #line 336 "rx-decode.opc"
5867                 int src AU = op[1] & 0x07;
5868                 if (trace)
5869                   {
5870                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5871                            "/** 10sz 0dsp a dst b src   mov%s   %1, %0 */",
5872                            op[0], op[1]);
5873                     printf ("  sz = 0x%x,", sz);
5874                     printf ("  dsp = 0x%x,", dsp);
5875                     printf ("  a = 0x%x,", a);
5876                     printf ("  dst = 0x%x,", dst);
5877                     printf ("  b = 0x%x,", b);
5878                     printf ("  src = 0x%x\n", src);
5879                   }
5880                 SYNTAX("mov%s   %1, %0");
5881 #line 336 "rx-decode.opc"
5882                 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
5883
5884               }
5885             break;
5886         }
5887       break;
5888     case 0x81:
5889         GETBYTE ();
5890         switch (op[1] & 0x00)
5891         {
5892           case 0x00:
5893             goto op_semantics_39;
5894             break;
5895         }
5896       break;
5897     case 0x82:
5898         GETBYTE ();
5899         switch (op[1] & 0x00)
5900         {
5901           case 0x00:
5902             goto op_semantics_39;
5903             break;
5904         }
5905       break;
5906     case 0x83:
5907         GETBYTE ();
5908         switch (op[1] & 0x00)
5909         {
5910           case 0x00:
5911             goto op_semantics_39;
5912             break;
5913         }
5914       break;
5915     case 0x84:
5916         GETBYTE ();
5917         switch (op[1] & 0x00)
5918         {
5919           case 0x00:
5920             goto op_semantics_39;
5921             break;
5922         }
5923       break;
5924     case 0x85:
5925         GETBYTE ();
5926         switch (op[1] & 0x00)
5927         {
5928           case 0x00:
5929             goto op_semantics_39;
5930             break;
5931         }
5932       break;
5933     case 0x86:
5934         GETBYTE ();
5935         switch (op[1] & 0x00)
5936         {
5937           case 0x00:
5938             goto op_semantics_39;
5939             break;
5940         }
5941       break;
5942     case 0x87:
5943         GETBYTE ();
5944         switch (op[1] & 0x00)
5945         {
5946           case 0x00:
5947             goto op_semantics_39;
5948             break;
5949         }
5950       break;
5951     case 0x88:
5952         GETBYTE ();
5953         switch (op[1] & 0x00)
5954         {
5955           case 0x00:
5956             op_semantics_40:
5957               {
5958                 /** 10sz 1dsp a src b dst       mov%s   %1, %0 */
5959 #line 333 "rx-decode.opc"
5960                 int sz AU = (op[0] >> 4) & 0x03;
5961 #line 333 "rx-decode.opc"
5962                 int dsp AU = op[0] & 0x07;
5963 #line 333 "rx-decode.opc"
5964                 int a AU = (op[1] >> 7) & 0x01;
5965 #line 333 "rx-decode.opc"
5966                 int src AU = (op[1] >> 4) & 0x07;
5967 #line 333 "rx-decode.opc"
5968                 int b AU = (op[1] >> 3) & 0x01;
5969 #line 333 "rx-decode.opc"
5970                 int dst AU = op[1] & 0x07;
5971                 if (trace)
5972                   {
5973                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5974                            "/** 10sz 1dsp a src b dst   mov%s   %1, %0 */",
5975                            op[0], op[1]);
5976                     printf ("  sz = 0x%x,", sz);
5977                     printf ("  dsp = 0x%x,", dsp);
5978                     printf ("  a = 0x%x,", a);
5979                     printf ("  src = 0x%x,", src);
5980                     printf ("  b = 0x%x,", b);
5981                     printf ("  dst = 0x%x\n", dst);
5982                   }
5983                 SYNTAX("mov%s   %1, %0");
5984 #line 333 "rx-decode.opc"
5985                 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
5986
5987               }
5988             break;
5989         }
5990       break;
5991     case 0x89:
5992         GETBYTE ();
5993         switch (op[1] & 0x00)
5994         {
5995           case 0x00:
5996             goto op_semantics_40;
5997             break;
5998         }
5999       break;
6000     case 0x8a:
6001         GETBYTE ();
6002         switch (op[1] & 0x00)
6003         {
6004           case 0x00:
6005             goto op_semantics_40;
6006             break;
6007         }
6008       break;
6009     case 0x8b:
6010         GETBYTE ();
6011         switch (op[1] & 0x00)
6012         {
6013           case 0x00:
6014             goto op_semantics_40;
6015             break;
6016         }
6017       break;
6018     case 0x8c:
6019         GETBYTE ();
6020         switch (op[1] & 0x00)
6021         {
6022           case 0x00:
6023             goto op_semantics_40;
6024             break;
6025         }
6026       break;
6027     case 0x8d:
6028         GETBYTE ();
6029         switch (op[1] & 0x00)
6030         {
6031           case 0x00:
6032             goto op_semantics_40;
6033             break;
6034         }
6035       break;
6036     case 0x8e:
6037         GETBYTE ();
6038         switch (op[1] & 0x00)
6039         {
6040           case 0x00:
6041             goto op_semantics_40;
6042             break;
6043         }
6044       break;
6045     case 0x8f:
6046         GETBYTE ();
6047         switch (op[1] & 0x00)
6048         {
6049           case 0x00:
6050             goto op_semantics_40;
6051             break;
6052         }
6053       break;
6054     case 0x90:
6055         GETBYTE ();
6056         switch (op[1] & 0x00)
6057         {
6058           case 0x00:
6059             goto op_semantics_39;
6060             break;
6061         }
6062       break;
6063     case 0x91:
6064         GETBYTE ();
6065         switch (op[1] & 0x00)
6066         {
6067           case 0x00:
6068             goto op_semantics_39;
6069             break;
6070         }
6071       break;
6072     case 0x92:
6073         GETBYTE ();
6074         switch (op[1] & 0x00)
6075         {
6076           case 0x00:
6077             goto op_semantics_39;
6078             break;
6079         }
6080       break;
6081     case 0x93:
6082         GETBYTE ();
6083         switch (op[1] & 0x00)
6084         {
6085           case 0x00:
6086             goto op_semantics_39;
6087             break;
6088         }
6089       break;
6090     case 0x94:
6091         GETBYTE ();
6092         switch (op[1] & 0x00)
6093         {
6094           case 0x00:
6095             goto op_semantics_39;
6096             break;
6097         }
6098       break;
6099     case 0x95:
6100         GETBYTE ();
6101         switch (op[1] & 0x00)
6102         {
6103           case 0x00:
6104             goto op_semantics_39;
6105             break;
6106         }
6107       break;
6108     case 0x96:
6109         GETBYTE ();
6110         switch (op[1] & 0x00)
6111         {
6112           case 0x00:
6113             goto op_semantics_39;
6114             break;
6115         }
6116       break;
6117     case 0x97:
6118         GETBYTE ();
6119         switch (op[1] & 0x00)
6120         {
6121           case 0x00:
6122             goto op_semantics_39;
6123             break;
6124         }
6125       break;
6126     case 0x98:
6127         GETBYTE ();
6128         switch (op[1] & 0x00)
6129         {
6130           case 0x00:
6131             goto op_semantics_40;
6132             break;
6133         }
6134       break;
6135     case 0x99:
6136         GETBYTE ();
6137         switch (op[1] & 0x00)
6138         {
6139           case 0x00:
6140             goto op_semantics_40;
6141             break;
6142         }
6143       break;
6144     case 0x9a:
6145         GETBYTE ();
6146         switch (op[1] & 0x00)
6147         {
6148           case 0x00:
6149             goto op_semantics_40;
6150             break;
6151         }
6152       break;
6153     case 0x9b:
6154         GETBYTE ();
6155         switch (op[1] & 0x00)
6156         {
6157           case 0x00:
6158             goto op_semantics_40;
6159             break;
6160         }
6161       break;
6162     case 0x9c:
6163         GETBYTE ();
6164         switch (op[1] & 0x00)
6165         {
6166           case 0x00:
6167             goto op_semantics_40;
6168             break;
6169         }
6170       break;
6171     case 0x9d:
6172         GETBYTE ();
6173         switch (op[1] & 0x00)
6174         {
6175           case 0x00:
6176             goto op_semantics_40;
6177             break;
6178         }
6179       break;
6180     case 0x9e:
6181         GETBYTE ();
6182         switch (op[1] & 0x00)
6183         {
6184           case 0x00:
6185             goto op_semantics_40;
6186             break;
6187         }
6188       break;
6189     case 0x9f:
6190         GETBYTE ();
6191         switch (op[1] & 0x00)
6192         {
6193           case 0x00:
6194             goto op_semantics_40;
6195             break;
6196         }
6197       break;
6198     case 0xa0:
6199         GETBYTE ();
6200         switch (op[1] & 0x00)
6201         {
6202           case 0x00:
6203             goto op_semantics_39;
6204             break;
6205         }
6206       break;
6207     case 0xa1:
6208         GETBYTE ();
6209         switch (op[1] & 0x00)
6210         {
6211           case 0x00:
6212             goto op_semantics_39;
6213             break;
6214         }
6215       break;
6216     case 0xa2:
6217         GETBYTE ();
6218         switch (op[1] & 0x00)
6219         {
6220           case 0x00:
6221             goto op_semantics_39;
6222             break;
6223         }
6224       break;
6225     case 0xa3:
6226         GETBYTE ();
6227         switch (op[1] & 0x00)
6228         {
6229           case 0x00:
6230             goto op_semantics_39;
6231             break;
6232         }
6233       break;
6234     case 0xa4:
6235         GETBYTE ();
6236         switch (op[1] & 0x00)
6237         {
6238           case 0x00:
6239             goto op_semantics_39;
6240             break;
6241         }
6242       break;
6243     case 0xa5:
6244         GETBYTE ();
6245         switch (op[1] & 0x00)
6246         {
6247           case 0x00:
6248             goto op_semantics_39;
6249             break;
6250         }
6251       break;
6252     case 0xa6:
6253         GETBYTE ();
6254         switch (op[1] & 0x00)
6255         {
6256           case 0x00:
6257             goto op_semantics_39;
6258             break;
6259         }
6260       break;
6261     case 0xa7:
6262         GETBYTE ();
6263         switch (op[1] & 0x00)
6264         {
6265           case 0x00:
6266             goto op_semantics_39;
6267             break;
6268         }
6269       break;
6270     case 0xa8:
6271         GETBYTE ();
6272         switch (op[1] & 0x00)
6273         {
6274           case 0x00:
6275             goto op_semantics_40;
6276             break;
6277         }
6278       break;
6279     case 0xa9:
6280         GETBYTE ();
6281         switch (op[1] & 0x00)
6282         {
6283           case 0x00:
6284             goto op_semantics_40;
6285             break;
6286         }
6287       break;
6288     case 0xaa:
6289         GETBYTE ();
6290         switch (op[1] & 0x00)
6291         {
6292           case 0x00:
6293             goto op_semantics_40;
6294             break;
6295         }
6296       break;
6297     case 0xab:
6298         GETBYTE ();
6299         switch (op[1] & 0x00)
6300         {
6301           case 0x00:
6302             goto op_semantics_40;
6303             break;
6304         }
6305       break;
6306     case 0xac:
6307         GETBYTE ();
6308         switch (op[1] & 0x00)
6309         {
6310           case 0x00:
6311             goto op_semantics_40;
6312             break;
6313         }
6314       break;
6315     case 0xad:
6316         GETBYTE ();
6317         switch (op[1] & 0x00)
6318         {
6319           case 0x00:
6320             goto op_semantics_40;
6321             break;
6322         }
6323       break;
6324     case 0xae:
6325         GETBYTE ();
6326         switch (op[1] & 0x00)
6327         {
6328           case 0x00:
6329             goto op_semantics_40;
6330             break;
6331         }
6332       break;
6333     case 0xaf:
6334         GETBYTE ();
6335         switch (op[1] & 0x00)
6336         {
6337           case 0x00:
6338             goto op_semantics_40;
6339             break;
6340         }
6341       break;
6342     case 0xb0:
6343         GETBYTE ();
6344         switch (op[1] & 0x00)
6345         {
6346           case 0x00:
6347             op_semantics_41:
6348               {
6349                 /** 1011 w dsp a src b dst      movu%s  %1, %0 */
6350 #line 356 "rx-decode.opc"
6351                 int w AU = (op[0] >> 3) & 0x01;
6352 #line 356 "rx-decode.opc"
6353                 int dsp AU = op[0] & 0x07;
6354 #line 356 "rx-decode.opc"
6355                 int a AU = (op[1] >> 7) & 0x01;
6356 #line 356 "rx-decode.opc"
6357                 int src AU = (op[1] >> 4) & 0x07;
6358 #line 356 "rx-decode.opc"
6359                 int b AU = (op[1] >> 3) & 0x01;
6360 #line 356 "rx-decode.opc"
6361                 int dst AU = op[1] & 0x07;
6362                 if (trace)
6363                   {
6364                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6365                            "/** 1011 w dsp a src b dst  movu%s  %1, %0 */",
6366                            op[0], op[1]);
6367                     printf ("  w = 0x%x,", w);
6368                     printf ("  dsp = 0x%x,", dsp);
6369                     printf ("  a = 0x%x,", a);
6370                     printf ("  src = 0x%x,", src);
6371                     printf ("  b = 0x%x,", b);
6372                     printf ("  dst = 0x%x\n", dst);
6373                   }
6374                 SYNTAX("movu%s  %1, %0");
6375 #line 356 "rx-decode.opc"
6376                 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
6377
6378               }
6379             break;
6380         }
6381       break;
6382     case 0xb1:
6383         GETBYTE ();
6384         switch (op[1] & 0x00)
6385         {
6386           case 0x00:
6387             goto op_semantics_41;
6388             break;
6389         }
6390       break;
6391     case 0xb2:
6392         GETBYTE ();
6393         switch (op[1] & 0x00)
6394         {
6395           case 0x00:
6396             goto op_semantics_41;
6397             break;
6398         }
6399       break;
6400     case 0xb3:
6401         GETBYTE ();
6402         switch (op[1] & 0x00)
6403         {
6404           case 0x00:
6405             goto op_semantics_41;
6406             break;
6407         }
6408       break;
6409     case 0xb4:
6410         GETBYTE ();
6411         switch (op[1] & 0x00)
6412         {
6413           case 0x00:
6414             goto op_semantics_41;
6415             break;
6416         }
6417       break;
6418     case 0xb5:
6419         GETBYTE ();
6420         switch (op[1] & 0x00)
6421         {
6422           case 0x00:
6423             goto op_semantics_41;
6424             break;
6425         }
6426       break;
6427     case 0xb6:
6428         GETBYTE ();
6429         switch (op[1] & 0x00)
6430         {
6431           case 0x00:
6432             goto op_semantics_41;
6433             break;
6434         }
6435       break;
6436     case 0xb7:
6437         GETBYTE ();
6438         switch (op[1] & 0x00)
6439         {
6440           case 0x00:
6441             goto op_semantics_41;
6442             break;
6443         }
6444       break;
6445     case 0xb8:
6446         GETBYTE ();
6447         switch (op[1] & 0x00)
6448         {
6449           case 0x00:
6450             goto op_semantics_41;
6451             break;
6452         }
6453       break;
6454     case 0xb9:
6455         GETBYTE ();
6456         switch (op[1] & 0x00)
6457         {
6458           case 0x00:
6459             goto op_semantics_41;
6460             break;
6461         }
6462       break;
6463     case 0xba:
6464         GETBYTE ();
6465         switch (op[1] & 0x00)
6466         {
6467           case 0x00:
6468             goto op_semantics_41;
6469             break;
6470         }
6471       break;
6472     case 0xbb:
6473         GETBYTE ();
6474         switch (op[1] & 0x00)
6475         {
6476           case 0x00:
6477             goto op_semantics_41;
6478             break;
6479         }
6480       break;
6481     case 0xbc:
6482         GETBYTE ();
6483         switch (op[1] & 0x00)
6484         {
6485           case 0x00:
6486             goto op_semantics_41;
6487             break;
6488         }
6489       break;
6490     case 0xbd:
6491         GETBYTE ();
6492         switch (op[1] & 0x00)
6493         {
6494           case 0x00:
6495             goto op_semantics_41;
6496             break;
6497         }
6498       break;
6499     case 0xbe:
6500         GETBYTE ();
6501         switch (op[1] & 0x00)
6502         {
6503           case 0x00:
6504             goto op_semantics_41;
6505             break;
6506         }
6507       break;
6508     case 0xbf:
6509         GETBYTE ();
6510         switch (op[1] & 0x00)
6511         {
6512           case 0x00:
6513             goto op_semantics_41;
6514             break;
6515         }
6516       break;
6517     case 0xc0:
6518         GETBYTE ();
6519         switch (op[1] & 0x00)
6520         {
6521           case 0x00:
6522             op_semantics_42:
6523               {
6524                 /** 11sz sd ss rsrc rdst        mov%s   %1, %0 */
6525 #line 314 "rx-decode.opc"
6526                 int sz AU = (op[0] >> 4) & 0x03;
6527 #line 314 "rx-decode.opc"
6528                 int sd AU = (op[0] >> 2) & 0x03;
6529 #line 314 "rx-decode.opc"
6530                 int ss AU = op[0] & 0x03;
6531 #line 314 "rx-decode.opc"
6532                 int rsrc AU = (op[1] >> 4) & 0x0f;
6533 #line 314 "rx-decode.opc"
6534                 int rdst AU = op[1] & 0x0f;
6535                 if (trace)
6536                   {
6537                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6538                            "/** 11sz sd ss rsrc rdst    mov%s   %1, %0 */",
6539                            op[0], op[1]);
6540                     printf ("  sz = 0x%x,", sz);
6541                     printf ("  sd = 0x%x,", sd);
6542                     printf ("  ss = 0x%x,", ss);
6543                     printf ("  rsrc = 0x%x,", rsrc);
6544                     printf ("  rdst = 0x%x\n", rdst);
6545                   }
6546                 SYNTAX("mov%s   %1, %0");
6547 #line 314 "rx-decode.opc"
6548                 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
6549                   {
6550                     ID(nop2);
6551                     SYNTAX ("nop\t; mov.l\tr0, r0");
6552                   }
6553                 else
6554                   {
6555                     ID(mov); sBWL(sz); F_____;
6556                     if ((ss == 3) && (sd != 3))
6557                 {
6558                   SD(ss, rdst, sz); DD(sd, rsrc, sz);
6559                 }
6560                     else
6561                 {
6562                   SD(ss, rsrc, sz); DD(sd, rdst, sz);
6563                 }
6564                   }
6565
6566               }
6567             break;
6568         }
6569       break;
6570     case 0xc1:
6571         GETBYTE ();
6572         switch (op[1] & 0x00)
6573         {
6574           case 0x00:
6575             goto op_semantics_42;
6576             break;
6577         }
6578       break;
6579     case 0xc2:
6580         GETBYTE ();
6581         switch (op[1] & 0x00)
6582         {
6583           case 0x00:
6584             goto op_semantics_42;
6585             break;
6586         }
6587       break;
6588     case 0xc3:
6589         GETBYTE ();
6590         switch (op[1] & 0x00)
6591         {
6592           case 0x00:
6593             goto op_semantics_42;
6594             break;
6595         }
6596       break;
6597     case 0xc4:
6598         GETBYTE ();
6599         switch (op[1] & 0x00)
6600         {
6601           case 0x00:
6602             goto op_semantics_42;
6603             break;
6604         }
6605       break;
6606     case 0xc5:
6607         GETBYTE ();
6608         switch (op[1] & 0x00)
6609         {
6610           case 0x00:
6611             goto op_semantics_42;
6612             break;
6613         }
6614       break;
6615     case 0xc6:
6616         GETBYTE ();
6617         switch (op[1] & 0x00)
6618         {
6619           case 0x00:
6620             goto op_semantics_42;
6621             break;
6622         }
6623       break;
6624     case 0xc7:
6625         GETBYTE ();
6626         switch (op[1] & 0x00)
6627         {
6628           case 0x00:
6629             goto op_semantics_42;
6630             break;
6631         }
6632       break;
6633     case 0xc8:
6634         GETBYTE ();
6635         switch (op[1] & 0x00)
6636         {
6637           case 0x00:
6638             goto op_semantics_42;
6639             break;
6640         }
6641       break;
6642     case 0xc9:
6643         GETBYTE ();
6644         switch (op[1] & 0x00)
6645         {
6646           case 0x00:
6647             goto op_semantics_42;
6648             break;
6649         }
6650       break;
6651     case 0xca:
6652         GETBYTE ();
6653         switch (op[1] & 0x00)
6654         {
6655           case 0x00:
6656             goto op_semantics_42;
6657             break;
6658         }
6659       break;
6660     case 0xcb:
6661         GETBYTE ();
6662         switch (op[1] & 0x00)
6663         {
6664           case 0x00:
6665             goto op_semantics_42;
6666             break;
6667         }
6668       break;
6669     case 0xcc:
6670         GETBYTE ();
6671         switch (op[1] & 0x00)
6672         {
6673           case 0x00:
6674             goto op_semantics_42;
6675             break;
6676         }
6677       break;
6678     case 0xcd:
6679         GETBYTE ();
6680         switch (op[1] & 0x00)
6681         {
6682           case 0x00:
6683             goto op_semantics_42;
6684             break;
6685         }
6686       break;
6687     case 0xce:
6688         GETBYTE ();
6689         switch (op[1] & 0x00)
6690         {
6691           case 0x00:
6692             goto op_semantics_42;
6693             break;
6694         }
6695       break;
6696     case 0xcf:
6697         GETBYTE ();
6698         switch (op[1] & 0x00)
6699         {
6700           case 0x00:
6701             goto op_semantics_42;
6702             break;
6703         }
6704       break;
6705     case 0xd0:
6706         GETBYTE ();
6707         switch (op[1] & 0x00)
6708         {
6709           case 0x00:
6710             goto op_semantics_42;
6711             break;
6712         }
6713       break;
6714     case 0xd1:
6715         GETBYTE ();
6716         switch (op[1] & 0x00)
6717         {
6718           case 0x00:
6719             goto op_semantics_42;
6720             break;
6721         }
6722       break;
6723     case 0xd2:
6724         GETBYTE ();
6725         switch (op[1] & 0x00)
6726         {
6727           case 0x00:
6728             goto op_semantics_42;
6729             break;
6730         }
6731       break;
6732     case 0xd3:
6733         GETBYTE ();
6734         switch (op[1] & 0x00)
6735         {
6736           case 0x00:
6737             goto op_semantics_42;
6738             break;
6739         }
6740       break;
6741     case 0xd4:
6742         GETBYTE ();
6743         switch (op[1] & 0x00)
6744         {
6745           case 0x00:
6746             goto op_semantics_42;
6747             break;
6748         }
6749       break;
6750     case 0xd5:
6751         GETBYTE ();
6752         switch (op[1] & 0x00)
6753         {
6754           case 0x00:
6755             goto op_semantics_42;
6756             break;
6757         }
6758       break;
6759     case 0xd6:
6760         GETBYTE ();
6761         switch (op[1] & 0x00)
6762         {
6763           case 0x00:
6764             goto op_semantics_42;
6765             break;
6766         }
6767       break;
6768     case 0xd7:
6769         GETBYTE ();
6770         switch (op[1] & 0x00)
6771         {
6772           case 0x00:
6773             goto op_semantics_42;
6774             break;
6775         }
6776       break;
6777     case 0xd8:
6778         GETBYTE ();
6779         switch (op[1] & 0x00)
6780         {
6781           case 0x00:
6782             goto op_semantics_42;
6783             break;
6784         }
6785       break;
6786     case 0xd9:
6787         GETBYTE ();
6788         switch (op[1] & 0x00)
6789         {
6790           case 0x00:
6791             goto op_semantics_42;
6792             break;
6793         }
6794       break;
6795     case 0xda:
6796         GETBYTE ();
6797         switch (op[1] & 0x00)
6798         {
6799           case 0x00:
6800             goto op_semantics_42;
6801             break;
6802         }
6803       break;
6804     case 0xdb:
6805         GETBYTE ();
6806         switch (op[1] & 0x00)
6807         {
6808           case 0x00:
6809             goto op_semantics_42;
6810             break;
6811         }
6812       break;
6813     case 0xdc:
6814         GETBYTE ();
6815         switch (op[1] & 0x00)
6816         {
6817           case 0x00:
6818             goto op_semantics_42;
6819             break;
6820         }
6821       break;
6822     case 0xdd:
6823         GETBYTE ();
6824         switch (op[1] & 0x00)
6825         {
6826           case 0x00:
6827             goto op_semantics_42;
6828             break;
6829         }
6830       break;
6831     case 0xde:
6832         GETBYTE ();
6833         switch (op[1] & 0x00)
6834         {
6835           case 0x00:
6836             goto op_semantics_42;
6837             break;
6838         }
6839       break;
6840     case 0xdf:
6841         GETBYTE ();
6842         switch (op[1] & 0x00)
6843         {
6844           case 0x00:
6845             goto op_semantics_42;
6846             break;
6847         }
6848       break;
6849     case 0xe0:
6850         GETBYTE ();
6851         switch (op[1] & 0x00)
6852         {
6853           case 0x00:
6854             goto op_semantics_42;
6855             break;
6856         }
6857       break;
6858     case 0xe1:
6859         GETBYTE ();
6860         switch (op[1] & 0x00)
6861         {
6862           case 0x00:
6863             goto op_semantics_42;
6864             break;
6865         }
6866       break;
6867     case 0xe2:
6868         GETBYTE ();
6869         switch (op[1] & 0x00)
6870         {
6871           case 0x00:
6872             goto op_semantics_42;
6873             break;
6874         }
6875       break;
6876     case 0xe3:
6877         GETBYTE ();
6878         switch (op[1] & 0x00)
6879         {
6880           case 0x00:
6881             goto op_semantics_42;
6882             break;
6883         }
6884       break;
6885     case 0xe4:
6886         GETBYTE ();
6887         switch (op[1] & 0x00)
6888         {
6889           case 0x00:
6890             goto op_semantics_42;
6891             break;
6892         }
6893       break;
6894     case 0xe5:
6895         GETBYTE ();
6896         switch (op[1] & 0x00)
6897         {
6898           case 0x00:
6899             goto op_semantics_42;
6900             break;
6901         }
6902       break;
6903     case 0xe6:
6904         GETBYTE ();
6905         switch (op[1] & 0x00)
6906         {
6907           case 0x00:
6908             goto op_semantics_42;
6909             break;
6910         }
6911       break;
6912     case 0xe7:
6913         GETBYTE ();
6914         switch (op[1] & 0x00)
6915         {
6916           case 0x00:
6917             goto op_semantics_42;
6918             break;
6919         }
6920       break;
6921     case 0xe8:
6922         GETBYTE ();
6923         switch (op[1] & 0x00)
6924         {
6925           case 0x00:
6926             goto op_semantics_42;
6927             break;
6928         }
6929       break;
6930     case 0xe9:
6931         GETBYTE ();
6932         switch (op[1] & 0x00)
6933         {
6934           case 0x00:
6935             goto op_semantics_42;
6936             break;
6937         }
6938       break;
6939     case 0xea:
6940         GETBYTE ();
6941         switch (op[1] & 0x00)
6942         {
6943           case 0x00:
6944             goto op_semantics_42;
6945             break;
6946         }
6947       break;
6948     case 0xeb:
6949         GETBYTE ();
6950         switch (op[1] & 0x00)
6951         {
6952           case 0x00:
6953             goto op_semantics_42;
6954             break;
6955         }
6956       break;
6957     case 0xec:
6958         GETBYTE ();
6959         switch (op[1] & 0x00)
6960         {
6961           case 0x00:
6962             goto op_semantics_42;
6963             break;
6964         }
6965       break;
6966     case 0xed:
6967         GETBYTE ();
6968         switch (op[1] & 0x00)
6969         {
6970           case 0x00:
6971             goto op_semantics_42;
6972             break;
6973         }
6974       break;
6975     case 0xee:
6976         GETBYTE ();
6977         switch (op[1] & 0x00)
6978         {
6979           case 0x00:
6980             goto op_semantics_42;
6981             break;
6982         }
6983       break;
6984     case 0xef:
6985         GETBYTE ();
6986         switch (op[1] & 0x00)
6987         {
6988           case 0x00:
6989             goto op_semantics_42;
6990             break;
6991         }
6992       break;
6993     case 0xf0:
6994         GETBYTE ();
6995         switch (op[1] & 0x08)
6996         {
6997           case 0x00:
6998             op_semantics_43:
6999               {
7000                 /** 1111 00sd rdst 0bit                 bset    #%1, %0%S0 */
7001 #line 939 "rx-decode.opc"
7002                 int sd AU = op[0] & 0x03;
7003 #line 939 "rx-decode.opc"
7004                 int rdst AU = (op[1] >> 4) & 0x0f;
7005 #line 939 "rx-decode.opc"
7006                 int bit AU = op[1] & 0x07;
7007                 if (trace)
7008                   {
7009                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7010                            "/** 1111 00sd rdst 0bit                     bset    #%1, %0%S0 */",
7011                            op[0], op[1]);
7012                     printf ("  sd = 0x%x,", sd);
7013                     printf ("  rdst = 0x%x,", rdst);
7014                     printf ("  bit = 0x%x\n", bit);
7015                   }
7016                 SYNTAX("bset    #%1, %0%S0");
7017 #line 939 "rx-decode.opc"
7018                 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
7019
7020               }
7021             break;
7022           case 0x08:
7023             op_semantics_44:
7024               {
7025                 /** 1111 00sd rdst 1bit                 bclr    #%1, %0%S0 */
7026 #line 951 "rx-decode.opc"
7027                 int sd AU = op[0] & 0x03;
7028 #line 951 "rx-decode.opc"
7029                 int rdst AU = (op[1] >> 4) & 0x0f;
7030 #line 951 "rx-decode.opc"
7031                 int bit AU = op[1] & 0x07;
7032                 if (trace)
7033                   {
7034                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7035                            "/** 1111 00sd rdst 1bit                     bclr    #%1, %0%S0 */",
7036                            op[0], op[1]);
7037                     printf ("  sd = 0x%x,", sd);
7038                     printf ("  rdst = 0x%x,", rdst);
7039                     printf ("  bit = 0x%x\n", bit);
7040                   }
7041                 SYNTAX("bclr    #%1, %0%S0");
7042 #line 951 "rx-decode.opc"
7043                 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
7044
7045               }
7046             break;
7047         }
7048       break;
7049     case 0xf1:
7050         GETBYTE ();
7051         switch (op[1] & 0x08)
7052         {
7053           case 0x00:
7054             goto op_semantics_43;
7055             break;
7056           case 0x08:
7057             goto op_semantics_44;
7058             break;
7059         }
7060       break;
7061     case 0xf2:
7062         GETBYTE ();
7063         switch (op[1] & 0x08)
7064         {
7065           case 0x00:
7066             goto op_semantics_43;
7067             break;
7068           case 0x08:
7069             goto op_semantics_44;
7070             break;
7071         }
7072       break;
7073     case 0xf3:
7074         GETBYTE ();
7075         switch (op[1] & 0x08)
7076         {
7077           case 0x00:
7078             goto op_semantics_43;
7079             break;
7080           case 0x08:
7081             goto op_semantics_44;
7082             break;
7083         }
7084       break;
7085     case 0xf4:
7086         GETBYTE ();
7087         switch (op[1] & 0x0c)
7088         {
7089           case 0x00:
7090           case 0x04:
7091             op_semantics_45:
7092               {
7093                 /** 1111 01sd rdst 0bit                 btst    #%2, %1%S1 */
7094 #line 963 "rx-decode.opc"
7095                 int sd AU = op[0] & 0x03;
7096 #line 963 "rx-decode.opc"
7097                 int rdst AU = (op[1] >> 4) & 0x0f;
7098 #line 963 "rx-decode.opc"
7099                 int bit AU = op[1] & 0x07;
7100                 if (trace)
7101                   {
7102                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7103                            "/** 1111 01sd rdst 0bit                     btst    #%2, %1%S1 */",
7104                            op[0], op[1]);
7105                     printf ("  sd = 0x%x,", sd);
7106                     printf ("  rdst = 0x%x,", rdst);
7107                     printf ("  bit = 0x%x\n", bit);
7108                   }
7109                 SYNTAX("btst    #%2, %1%S1");
7110 #line 963 "rx-decode.opc"
7111                 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
7112
7113               }
7114             break;
7115           case 0x08:
7116             op_semantics_46:
7117               {
7118                 /** 1111 01ss rsrc 10sz         push%s  %1 */
7119 #line 381 "rx-decode.opc"
7120                 int ss AU = op[0] & 0x03;
7121 #line 381 "rx-decode.opc"
7122                 int rsrc AU = (op[1] >> 4) & 0x0f;
7123 #line 381 "rx-decode.opc"
7124                 int sz AU = op[1] & 0x03;
7125                 if (trace)
7126                   {
7127                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7128                            "/** 1111 01ss rsrc 10sz             push%s  %1 */",
7129                            op[0], op[1]);
7130                     printf ("  ss = 0x%x,", ss);
7131                     printf ("  rsrc = 0x%x,", rsrc);
7132                     printf ("  sz = 0x%x\n", sz);
7133                   }
7134                 SYNTAX("push%s  %1");
7135 #line 381 "rx-decode.opc"
7136                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
7137
7138               /*----------------------------------------------------------------------*/
7139               /* XCHG                                                                   */
7140
7141               }
7142             break;
7143           default: UNSUPPORTED(); break;
7144         }
7145       break;
7146     case 0xf5:
7147         GETBYTE ();
7148         switch (op[1] & 0x0c)
7149         {
7150           case 0x00:
7151           case 0x04:
7152             goto op_semantics_45;
7153             break;
7154           case 0x08:
7155             goto op_semantics_46;
7156             break;
7157           default: UNSUPPORTED(); break;
7158         }
7159       break;
7160     case 0xf6:
7161         GETBYTE ();
7162         switch (op[1] & 0x0c)
7163         {
7164           case 0x00:
7165           case 0x04:
7166             goto op_semantics_45;
7167             break;
7168           case 0x08:
7169             goto op_semantics_46;
7170             break;
7171           default: UNSUPPORTED(); break;
7172         }
7173       break;
7174     case 0xf7:
7175         GETBYTE ();
7176         switch (op[1] & 0x0c)
7177         {
7178           case 0x00:
7179           case 0x04:
7180             goto op_semantics_45;
7181             break;
7182           case 0x08:
7183             goto op_semantics_46;
7184             break;
7185           default: UNSUPPORTED(); break;
7186         }
7187       break;
7188     case 0xf8:
7189         GETBYTE ();
7190         switch (op[1] & 0x00)
7191         {
7192           case 0x00:
7193             op_semantics_47:
7194               {
7195                 /** 1111 10sd rdst im sz        mov%s   #%1, %0 */
7196 #line 292 "rx-decode.opc"
7197                 int sd AU = op[0] & 0x03;
7198 #line 292 "rx-decode.opc"
7199                 int rdst AU = (op[1] >> 4) & 0x0f;
7200 #line 292 "rx-decode.opc"
7201                 int im AU = (op[1] >> 2) & 0x03;
7202 #line 292 "rx-decode.opc"
7203                 int sz AU = op[1] & 0x03;
7204                 if (trace)
7205                   {
7206                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7207                            "/** 1111 10sd rdst im sz    mov%s   #%1, %0 */",
7208                            op[0], op[1]);
7209                     printf ("  sd = 0x%x,", sd);
7210                     printf ("  rdst = 0x%x,", rdst);
7211                     printf ("  im = 0x%x,", im);
7212                     printf ("  sz = 0x%x\n", sz);
7213                   }
7214                 SYNTAX("mov%s   #%1, %0");
7215 #line 292 "rx-decode.opc"
7216                 ID(mov); DD(sd, rdst, sz);
7217                 if ((im == 1 && sz == 0)
7218                     || (im == 2 && sz == 1)
7219                     || (im == 0 && sz == 2))
7220                   {
7221                     BWL (sz);
7222                     SC(IMM(im));
7223                   }
7224                 else
7225                   {
7226                     sBWL (sz);
7227                     SC(IMMex(im));
7228                   }
7229                  F_____;
7230
7231               }
7232             break;
7233         }
7234       break;
7235     case 0xf9:
7236         GETBYTE ();
7237         switch (op[1] & 0x00)
7238         {
7239           case 0x00:
7240             goto op_semantics_47;
7241             break;
7242         }
7243       break;
7244     case 0xfa:
7245         GETBYTE ();
7246         switch (op[1] & 0x00)
7247         {
7248           case 0x00:
7249             goto op_semantics_47;
7250             break;
7251         }
7252       break;
7253     case 0xfb:
7254         GETBYTE ();
7255         switch (op[1] & 0x00)
7256         {
7257           case 0x00:
7258             goto op_semantics_47;
7259             break;
7260         }
7261       break;
7262     case 0xfc:
7263         GETBYTE ();
7264         switch (op[1] & 0xff)
7265         {
7266           case 0x03:
7267               GETBYTE ();
7268               switch (op[2] & 0x00)
7269               {
7270                 case 0x00:
7271                     {
7272                       /** 1111 1100 0000 0011 rsrc rdst sbb     %1, %0 */
7273 #line 555 "rx-decode.opc"
7274                       int rsrc AU = (op[2] >> 4) & 0x0f;
7275 #line 555 "rx-decode.opc"
7276                       int rdst AU = op[2] & 0x0f;
7277                       if (trace)
7278                         {
7279                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7280                                  "/** 1111 1100 0000 0011 rsrc rdst     sbb     %1, %0 */",
7281                                  op[0], op[1], op[2]);
7282                           printf ("  rsrc = 0x%x,", rsrc);
7283                           printf ("  rdst = 0x%x\n", rdst);
7284                         }
7285                       SYNTAX("sbb       %1, %0");
7286 #line 555 "rx-decode.opc"
7287                       ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
7288
7289                       /* FIXME: only supports .L */
7290                     }
7291                   break;
7292               }
7293             break;
7294           case 0x07:
7295               GETBYTE ();
7296               switch (op[2] & 0x00)
7297               {
7298                 case 0x00:
7299                     {
7300                       /** 1111 1100 0000 0111 rsrc rdst neg     %2, %0 */
7301 #line 486 "rx-decode.opc"
7302                       int rsrc AU = (op[2] >> 4) & 0x0f;
7303 #line 486 "rx-decode.opc"
7304                       int rdst AU = op[2] & 0x0f;
7305                       if (trace)
7306                         {
7307                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7308                                  "/** 1111 1100 0000 0111 rsrc rdst     neg     %2, %0 */",
7309                                  op[0], op[1], op[2]);
7310                           printf ("  rsrc = 0x%x,", rsrc);
7311                           printf ("  rdst = 0x%x\n", rdst);
7312                         }
7313                       SYNTAX("neg       %2, %0");
7314 #line 486 "rx-decode.opc"
7315                       ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
7316
7317                     /*----------------------------------------------------------------------*/
7318                     /* ADC                                                                      */
7319
7320                     }
7321                   break;
7322               }
7323             break;
7324           case 0x0b:
7325               GETBYTE ();
7326               switch (op[2] & 0x00)
7327               {
7328                 case 0x00:
7329                     {
7330                       /** 1111 1100 0000 1011 rsrc rdst adc     %1, %0 */
7331 #line 495 "rx-decode.opc"
7332                       int rsrc AU = (op[2] >> 4) & 0x0f;
7333 #line 495 "rx-decode.opc"
7334                       int rdst AU = op[2] & 0x0f;
7335                       if (trace)
7336                         {
7337                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7338                                  "/** 1111 1100 0000 1011 rsrc rdst     adc     %1, %0 */",
7339                                  op[0], op[1], op[2]);
7340                           printf ("  rsrc = 0x%x,", rsrc);
7341                           printf ("  rdst = 0x%x\n", rdst);
7342                         }
7343                       SYNTAX("adc       %1, %0");
7344 #line 495 "rx-decode.opc"
7345                       ID(adc); SR(rsrc); DR(rdst); F_OSZC;
7346
7347                     }
7348                   break;
7349               }
7350             break;
7351           case 0x0f:
7352               GETBYTE ();
7353               switch (op[2] & 0x00)
7354               {
7355                 case 0x00:
7356                     {
7357                       /** 1111 1100 0000 1111 rsrc rdst abs     %1, %0 */
7358 #line 568 "rx-decode.opc"
7359                       int rsrc AU = (op[2] >> 4) & 0x0f;
7360 #line 568 "rx-decode.opc"
7361                       int rdst AU = op[2] & 0x0f;
7362                       if (trace)
7363                         {
7364                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7365                                  "/** 1111 1100 0000 1111 rsrc rdst     abs     %1, %0 */",
7366                                  op[0], op[1], op[2]);
7367                           printf ("  rsrc = 0x%x,", rsrc);
7368                           printf ("  rdst = 0x%x\n", rdst);
7369                         }
7370                       SYNTAX("abs       %1, %0");
7371 #line 568 "rx-decode.opc"
7372                       ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
7373
7374                     /*----------------------------------------------------------------------*/
7375                     /* MAX                                                                      */
7376
7377                     }
7378                   break;
7379               }
7380             break;
7381           case 0x10:
7382               GETBYTE ();
7383               switch (op[2] & 0x00)
7384               {
7385                 case 0x00:
7386                   op_semantics_48:
7387                     {
7388                       /** 1111 1100 0001 00ss rsrc rdst max     %1%S1, %0 */
7389 #line 587 "rx-decode.opc"
7390                       int ss AU = op[1] & 0x03;
7391 #line 587 "rx-decode.opc"
7392                       int rsrc AU = (op[2] >> 4) & 0x0f;
7393 #line 587 "rx-decode.opc"
7394                       int rdst AU = op[2] & 0x0f;
7395                       if (trace)
7396                         {
7397                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7398                                  "/** 1111 1100 0001 00ss rsrc rdst     max     %1%S1, %0 */",
7399                                  op[0], op[1], op[2]);
7400                           printf ("  ss = 0x%x,", ss);
7401                           printf ("  rsrc = 0x%x,", rsrc);
7402                           printf ("  rdst = 0x%x\n", rdst);
7403                         }
7404                       SYNTAX("max       %1%S1, %0");
7405 #line 587 "rx-decode.opc"
7406                       if (ss == 3 && rsrc == 0 && rdst == 0)
7407                         {
7408                           ID(nop3);
7409                           SYNTAX("nop\t; max\tr0, r0");
7410                         }
7411                       else
7412                         {
7413                           ID(max); SP(ss, rsrc); DR(rdst);
7414                         }
7415
7416                     }
7417                   break;
7418               }
7419             break;
7420           case 0x11:
7421               GETBYTE ();
7422               switch (op[2] & 0x00)
7423               {
7424                 case 0x00:
7425                   goto op_semantics_48;
7426                   break;
7427               }
7428             break;
7429           case 0x12:
7430               GETBYTE ();
7431               switch (op[2] & 0x00)
7432               {
7433                 case 0x00:
7434                   goto op_semantics_48;
7435                   break;
7436               }
7437             break;
7438           case 0x13:
7439               GETBYTE ();
7440               switch (op[2] & 0x00)
7441               {
7442                 case 0x00:
7443                   goto op_semantics_48;
7444                   break;
7445               }
7446             break;
7447           case 0x14:
7448               GETBYTE ();
7449               switch (op[2] & 0x00)
7450               {
7451                 case 0x00:
7452                   op_semantics_49:
7453                     {
7454                       /** 1111 1100 0001 01ss rsrc rdst min     %1%S1, %0 */
7455 #line 607 "rx-decode.opc"
7456                       int ss AU = op[1] & 0x03;
7457 #line 607 "rx-decode.opc"
7458                       int rsrc AU = (op[2] >> 4) & 0x0f;
7459 #line 607 "rx-decode.opc"
7460                       int rdst AU = op[2] & 0x0f;
7461                       if (trace)
7462                         {
7463                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7464                                  "/** 1111 1100 0001 01ss rsrc rdst     min     %1%S1, %0 */",
7465                                  op[0], op[1], op[2]);
7466                           printf ("  ss = 0x%x,", ss);
7467                           printf ("  rsrc = 0x%x,", rsrc);
7468                           printf ("  rdst = 0x%x\n", rdst);
7469                         }
7470                       SYNTAX("min       %1%S1, %0");
7471 #line 607 "rx-decode.opc"
7472                       ID(min); SP(ss, rsrc); DR(rdst);
7473
7474                     }
7475                   break;
7476               }
7477             break;
7478           case 0x15:
7479               GETBYTE ();
7480               switch (op[2] & 0x00)
7481               {
7482                 case 0x00:
7483                   goto op_semantics_49;
7484                   break;
7485               }
7486             break;
7487           case 0x16:
7488               GETBYTE ();
7489               switch (op[2] & 0x00)
7490               {
7491                 case 0x00:
7492                   goto op_semantics_49;
7493                   break;
7494               }
7495             break;
7496           case 0x17:
7497               GETBYTE ();
7498               switch (op[2] & 0x00)
7499               {
7500                 case 0x00:
7501                   goto op_semantics_49;
7502                   break;
7503               }
7504             break;
7505           case 0x18:
7506               GETBYTE ();
7507               switch (op[2] & 0x00)
7508               {
7509                 case 0x00:
7510                   op_semantics_50:
7511                     {
7512                       /** 1111 1100 0001 10ss rsrc rdst emul    %1%S1, %0 */
7513 #line 665 "rx-decode.opc"
7514                       int ss AU = op[1] & 0x03;
7515 #line 665 "rx-decode.opc"
7516                       int rsrc AU = (op[2] >> 4) & 0x0f;
7517 #line 665 "rx-decode.opc"
7518                       int rdst AU = op[2] & 0x0f;
7519                       if (trace)
7520                         {
7521                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7522                                  "/** 1111 1100 0001 10ss rsrc rdst     emul    %1%S1, %0 */",
7523                                  op[0], op[1], op[2]);
7524                           printf ("  ss = 0x%x,", ss);
7525                           printf ("  rsrc = 0x%x,", rsrc);
7526                           printf ("  rdst = 0x%x\n", rdst);
7527                         }
7528                       SYNTAX("emul      %1%S1, %0");
7529 #line 665 "rx-decode.opc"
7530                       ID(emul); SP(ss, rsrc); DR(rdst);
7531
7532                     }
7533                   break;
7534               }
7535             break;
7536           case 0x19:
7537               GETBYTE ();
7538               switch (op[2] & 0x00)
7539               {
7540                 case 0x00:
7541                   goto op_semantics_50;
7542                   break;
7543               }
7544             break;
7545           case 0x1a:
7546               GETBYTE ();
7547               switch (op[2] & 0x00)
7548               {
7549                 case 0x00:
7550                   goto op_semantics_50;
7551                   break;
7552               }
7553             break;
7554           case 0x1b:
7555               GETBYTE ();
7556               switch (op[2] & 0x00)
7557               {
7558                 case 0x00:
7559                   goto op_semantics_50;
7560                   break;
7561               }
7562             break;
7563           case 0x1c:
7564               GETBYTE ();
7565               switch (op[2] & 0x00)
7566               {
7567                 case 0x00:
7568                   op_semantics_51:
7569                     {
7570                       /** 1111 1100 0001 11ss rsrc rdst emulu   %1%S1, %0 */
7571 #line 677 "rx-decode.opc"
7572                       int ss AU = op[1] & 0x03;
7573 #line 677 "rx-decode.opc"
7574                       int rsrc AU = (op[2] >> 4) & 0x0f;
7575 #line 677 "rx-decode.opc"
7576                       int rdst AU = op[2] & 0x0f;
7577                       if (trace)
7578                         {
7579                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7580                                  "/** 1111 1100 0001 11ss rsrc rdst     emulu   %1%S1, %0 */",
7581                                  op[0], op[1], op[2]);
7582                           printf ("  ss = 0x%x,", ss);
7583                           printf ("  rsrc = 0x%x,", rsrc);
7584                           printf ("  rdst = 0x%x\n", rdst);
7585                         }
7586                       SYNTAX("emulu     %1%S1, %0");
7587 #line 677 "rx-decode.opc"
7588                       ID(emulu); SP(ss, rsrc); DR(rdst);
7589
7590                     }
7591                   break;
7592               }
7593             break;
7594           case 0x1d:
7595               GETBYTE ();
7596               switch (op[2] & 0x00)
7597               {
7598                 case 0x00:
7599                   goto op_semantics_51;
7600                   break;
7601               }
7602             break;
7603           case 0x1e:
7604               GETBYTE ();
7605               switch (op[2] & 0x00)
7606               {
7607                 case 0x00:
7608                   goto op_semantics_51;
7609                   break;
7610               }
7611             break;
7612           case 0x1f:
7613               GETBYTE ();
7614               switch (op[2] & 0x00)
7615               {
7616                 case 0x00:
7617                   goto op_semantics_51;
7618                   break;
7619               }
7620             break;
7621           case 0x20:
7622               GETBYTE ();
7623               switch (op[2] & 0x00)
7624               {
7625                 case 0x00:
7626                   op_semantics_52:
7627                     {
7628                       /** 1111 1100 0010 00ss rsrc rdst div     %1%S1, %0 */
7629 #line 689 "rx-decode.opc"
7630                       int ss AU = op[1] & 0x03;
7631 #line 689 "rx-decode.opc"
7632                       int rsrc AU = (op[2] >> 4) & 0x0f;
7633 #line 689 "rx-decode.opc"
7634                       int rdst AU = op[2] & 0x0f;
7635                       if (trace)
7636                         {
7637                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7638                                  "/** 1111 1100 0010 00ss rsrc rdst     div     %1%S1, %0 */",
7639                                  op[0], op[1], op[2]);
7640                           printf ("  ss = 0x%x,", ss);
7641                           printf ("  rsrc = 0x%x,", rsrc);
7642                           printf ("  rdst = 0x%x\n", rdst);
7643                         }
7644                       SYNTAX("div       %1%S1, %0");
7645 #line 689 "rx-decode.opc"
7646                       ID(div); SP(ss, rsrc); DR(rdst); F_O___;
7647
7648                     }
7649                   break;
7650               }
7651             break;
7652           case 0x21:
7653               GETBYTE ();
7654               switch (op[2] & 0x00)
7655               {
7656                 case 0x00:
7657                   goto op_semantics_52;
7658                   break;
7659               }
7660             break;
7661           case 0x22:
7662               GETBYTE ();
7663               switch (op[2] & 0x00)
7664               {
7665                 case 0x00:
7666                   goto op_semantics_52;
7667                   break;
7668               }
7669             break;
7670           case 0x23:
7671               GETBYTE ();
7672               switch (op[2] & 0x00)
7673               {
7674                 case 0x00:
7675                   goto op_semantics_52;
7676                   break;
7677               }
7678             break;
7679           case 0x24:
7680               GETBYTE ();
7681               switch (op[2] & 0x00)
7682               {
7683                 case 0x00:
7684                   op_semantics_53:
7685                     {
7686                       /** 1111 1100 0010 01ss rsrc rdst divu    %1%S1, %0 */
7687 #line 701 "rx-decode.opc"
7688                       int ss AU = op[1] & 0x03;
7689 #line 701 "rx-decode.opc"
7690                       int rsrc AU = (op[2] >> 4) & 0x0f;
7691 #line 701 "rx-decode.opc"
7692                       int rdst AU = op[2] & 0x0f;
7693                       if (trace)
7694                         {
7695                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7696                                  "/** 1111 1100 0010 01ss rsrc rdst     divu    %1%S1, %0 */",
7697                                  op[0], op[1], op[2]);
7698                           printf ("  ss = 0x%x,", ss);
7699                           printf ("  rsrc = 0x%x,", rsrc);
7700                           printf ("  rdst = 0x%x\n", rdst);
7701                         }
7702                       SYNTAX("divu      %1%S1, %0");
7703 #line 701 "rx-decode.opc"
7704                       ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
7705
7706                     }
7707                   break;
7708               }
7709             break;
7710           case 0x25:
7711               GETBYTE ();
7712               switch (op[2] & 0x00)
7713               {
7714                 case 0x00:
7715                   goto op_semantics_53;
7716                   break;
7717               }
7718             break;
7719           case 0x26:
7720               GETBYTE ();
7721               switch (op[2] & 0x00)
7722               {
7723                 case 0x00:
7724                   goto op_semantics_53;
7725                   break;
7726               }
7727             break;
7728           case 0x27:
7729               GETBYTE ();
7730               switch (op[2] & 0x00)
7731               {
7732                 case 0x00:
7733                   goto op_semantics_53;
7734                   break;
7735               }
7736             break;
7737           case 0x30:
7738               GETBYTE ();
7739               switch (op[2] & 0x00)
7740               {
7741                 case 0x00:
7742                   op_semantics_54:
7743                     {
7744                       /** 1111 1100 0011 00ss rsrc rdst tst     %1%S1, %2 */
7745 #line 474 "rx-decode.opc"
7746                       int ss AU = op[1] & 0x03;
7747 #line 474 "rx-decode.opc"
7748                       int rsrc AU = (op[2] >> 4) & 0x0f;
7749 #line 474 "rx-decode.opc"
7750                       int rdst AU = op[2] & 0x0f;
7751                       if (trace)
7752                         {
7753                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7754                                  "/** 1111 1100 0011 00ss rsrc rdst     tst     %1%S1, %2 */",
7755                                  op[0], op[1], op[2]);
7756                           printf ("  ss = 0x%x,", ss);
7757                           printf ("  rsrc = 0x%x,", rsrc);
7758                           printf ("  rdst = 0x%x\n", rdst);
7759                         }
7760                       SYNTAX("tst       %1%S1, %2");
7761 #line 474 "rx-decode.opc"
7762                       ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
7763
7764                     }
7765                   break;
7766               }
7767             break;
7768           case 0x31:
7769               GETBYTE ();
7770               switch (op[2] & 0x00)
7771               {
7772                 case 0x00:
7773                   goto op_semantics_54;
7774                   break;
7775               }
7776             break;
7777           case 0x32:
7778               GETBYTE ();
7779               switch (op[2] & 0x00)
7780               {
7781                 case 0x00:
7782                   goto op_semantics_54;
7783                   break;
7784               }
7785             break;
7786           case 0x33:
7787               GETBYTE ();
7788               switch (op[2] & 0x00)
7789               {
7790                 case 0x00:
7791                   goto op_semantics_54;
7792                   break;
7793               }
7794             break;
7795           case 0x34:
7796               GETBYTE ();
7797               switch (op[2] & 0x00)
7798               {
7799                 case 0x00:
7800                   op_semantics_55:
7801                     {
7802                       /** 1111 1100 0011 01ss rsrc rdst xor     %1%S1, %0 */
7803 #line 453 "rx-decode.opc"
7804                       int ss AU = op[1] & 0x03;
7805 #line 453 "rx-decode.opc"
7806                       int rsrc AU = (op[2] >> 4) & 0x0f;
7807 #line 453 "rx-decode.opc"
7808                       int rdst AU = op[2] & 0x0f;
7809                       if (trace)
7810                         {
7811                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7812                                  "/** 1111 1100 0011 01ss rsrc rdst     xor     %1%S1, %0 */",
7813                                  op[0], op[1], op[2]);
7814                           printf ("  ss = 0x%x,", ss);
7815                           printf ("  rsrc = 0x%x,", rsrc);
7816                           printf ("  rdst = 0x%x\n", rdst);
7817                         }
7818                       SYNTAX("xor       %1%S1, %0");
7819 #line 453 "rx-decode.opc"
7820                       ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
7821
7822                     }
7823                   break;
7824               }
7825             break;
7826           case 0x35:
7827               GETBYTE ();
7828               switch (op[2] & 0x00)
7829               {
7830                 case 0x00:
7831                   goto op_semantics_55;
7832                   break;
7833               }
7834             break;
7835           case 0x36:
7836               GETBYTE ();
7837               switch (op[2] & 0x00)
7838               {
7839                 case 0x00:
7840                   goto op_semantics_55;
7841                   break;
7842               }
7843             break;
7844           case 0x37:
7845               GETBYTE ();
7846               switch (op[2] & 0x00)
7847               {
7848                 case 0x00:
7849                   goto op_semantics_55;
7850                   break;
7851               }
7852             break;
7853           case 0x3b:
7854               GETBYTE ();
7855               switch (op[2] & 0x00)
7856               {
7857                 case 0x00:
7858                     {
7859                       /** 1111 1100 0011 1011 rsrc rdst not     %1, %0 */
7860 #line 465 "rx-decode.opc"
7861                       int rsrc AU = (op[2] >> 4) & 0x0f;
7862 #line 465 "rx-decode.opc"
7863                       int rdst AU = op[2] & 0x0f;
7864                       if (trace)
7865                         {
7866                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7867                                  "/** 1111 1100 0011 1011 rsrc rdst     not     %1, %0 */",
7868                                  op[0], op[1], op[2]);
7869                           printf ("  rsrc = 0x%x,", rsrc);
7870                           printf ("  rdst = 0x%x\n", rdst);
7871                         }
7872                       SYNTAX("not       %1, %0");
7873 #line 465 "rx-decode.opc"
7874                       ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
7875
7876                     /*----------------------------------------------------------------------*/
7877                     /* TST                                                                      */
7878
7879                     }
7880                   break;
7881               }
7882             break;
7883           case 0x40:
7884               GETBYTE ();
7885               switch (op[2] & 0x00)
7886               {
7887                 case 0x00:
7888                   op_semantics_56:
7889                     {
7890                       /** 1111 1100 0100 00ss rsrc rdst xchg    %1%S1, %0 */
7891 #line 387 "rx-decode.opc"
7892                       int ss AU = op[1] & 0x03;
7893 #line 387 "rx-decode.opc"
7894                       int rsrc AU = (op[2] >> 4) & 0x0f;
7895 #line 387 "rx-decode.opc"
7896                       int rdst AU = op[2] & 0x0f;
7897                       if (trace)
7898                         {
7899                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7900                                  "/** 1111 1100 0100 00ss rsrc rdst     xchg    %1%S1, %0 */",
7901                                  op[0], op[1], op[2]);
7902                           printf ("  ss = 0x%x,", ss);
7903                           printf ("  rsrc = 0x%x,", rsrc);
7904                           printf ("  rdst = 0x%x\n", rdst);
7905                         }
7906                       SYNTAX("xchg      %1%S1, %0");
7907 #line 387 "rx-decode.opc"
7908                       ID(xchg); DR(rdst); SP(ss, rsrc);
7909
7910                     }
7911                   break;
7912               }
7913             break;
7914           case 0x41:
7915               GETBYTE ();
7916               switch (op[2] & 0x00)
7917               {
7918                 case 0x00:
7919                   goto op_semantics_56;
7920                   break;
7921               }
7922             break;
7923           case 0x42:
7924               GETBYTE ();
7925               switch (op[2] & 0x00)
7926               {
7927                 case 0x00:
7928                   goto op_semantics_56;
7929                   break;
7930               }
7931             break;
7932           case 0x43:
7933               GETBYTE ();
7934               switch (op[2] & 0x00)
7935               {
7936                 case 0x00:
7937                   goto op_semantics_56;
7938                   break;
7939               }
7940             break;
7941           case 0x44:
7942               GETBYTE ();
7943               switch (op[2] & 0x00)
7944               {
7945                 case 0x00:
7946                   op_semantics_57:
7947                     {
7948                       /** 1111 1100 0100 01sd rsrc rdst itof    %1%S1, %0 */
7949 #line 930 "rx-decode.opc"
7950                       int sd AU = op[1] & 0x03;
7951 #line 930 "rx-decode.opc"
7952                       int rsrc AU = (op[2] >> 4) & 0x0f;
7953 #line 930 "rx-decode.opc"
7954                       int rdst AU = op[2] & 0x0f;
7955                       if (trace)
7956                         {
7957                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7958                                  "/** 1111 1100 0100 01sd rsrc rdst     itof    %1%S1, %0 */",
7959                                  op[0], op[1], op[2]);
7960                           printf ("  sd = 0x%x,", sd);
7961                           printf ("  rsrc = 0x%x,", rsrc);
7962                           printf ("  rdst = 0x%x\n", rdst);
7963                         }
7964                       SYNTAX("itof      %1%S1, %0");
7965 #line 930 "rx-decode.opc"
7966                       ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
7967
7968                     }
7969                   break;
7970               }
7971             break;
7972           case 0x45:
7973               GETBYTE ();
7974               switch (op[2] & 0x00)
7975               {
7976                 case 0x00:
7977                   goto op_semantics_57;
7978                   break;
7979               }
7980             break;
7981           case 0x46:
7982               GETBYTE ();
7983               switch (op[2] & 0x00)
7984               {
7985                 case 0x00:
7986                   goto op_semantics_57;
7987                   break;
7988               }
7989             break;
7990           case 0x47:
7991               GETBYTE ();
7992               switch (op[2] & 0x00)
7993               {
7994                 case 0x00:
7995                   goto op_semantics_57;
7996                   break;
7997               }
7998             break;
7999           case 0x4b:
8000               GETBYTE ();
8001               switch (op[2] & 0x00)
8002               {
8003                 case 0x00:
8004                     {
8005                       /** 1111 1100 0100 1011 rsrc rdst stz     %1, %0 */
8006 #line 1056 "rx-decode.opc"
8007                       int rsrc AU = (op[2] >> 4) & 0x0f;
8008 #line 1056 "rx-decode.opc"
8009                       int rdst AU = op[2] & 0x0f;
8010                       if (trace)
8011                         {
8012                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8013                                  "/** 1111 1100 0100 1011 rsrc rdst     stz     %1, %0 */",
8014                                  op[0], op[1], op[2]);
8015                           printf ("  rsrc = 0x%x,", rsrc);
8016                           printf ("  rdst = 0x%x\n", rdst);
8017                         }
8018                       SYNTAX("stz       %1, %0");
8019 #line 1056 "rx-decode.opc"
8020                       ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
8021
8022                     }
8023                   break;
8024               }
8025             break;
8026           case 0x4f:
8027               GETBYTE ();
8028               switch (op[2] & 0x00)
8029               {
8030                 case 0x00:
8031                     {
8032                       /** 1111 1100 0100 1111 rsrc rdst stnz    %1, %0 */
8033 #line 1059 "rx-decode.opc"
8034                       int rsrc AU = (op[2] >> 4) & 0x0f;
8035 #line 1059 "rx-decode.opc"
8036                       int rdst AU = op[2] & 0x0f;
8037                       if (trace)
8038                         {
8039                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8040                                  "/** 1111 1100 0100 1111 rsrc rdst     stnz    %1, %0 */",
8041                                  op[0], op[1], op[2]);
8042                           printf ("  rsrc = 0x%x,", rsrc);
8043                           printf ("  rdst = 0x%x\n", rdst);
8044                         }
8045                       SYNTAX("stnz      %1, %0");
8046 #line 1059 "rx-decode.opc"
8047                       ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
8048
8049                     }
8050                   break;
8051               }
8052             break;
8053           case 0x54:
8054               GETBYTE ();
8055               switch (op[2] & 0x00)
8056               {
8057                 case 0x00:
8058                   op_semantics_58:
8059                     {
8060                       /** 1111 1100 0101 01sd rsrc rdst utof    %1%S1, %0 */
8061 #line 1116 "rx-decode.opc"
8062                       int sd AU = op[1] & 0x03;
8063 #line 1116 "rx-decode.opc"
8064                       int rsrc AU = (op[2] >> 4) & 0x0f;
8065 #line 1116 "rx-decode.opc"
8066                       int rdst AU = op[2] & 0x0f;
8067                       if (trace)
8068                         {
8069                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8070                                  "/** 1111 1100 0101 01sd rsrc rdst     utof    %1%S1, %0 */",
8071                                  op[0], op[1], op[2]);
8072                           printf ("  sd = 0x%x,", sd);
8073                           printf ("  rsrc = 0x%x,", rsrc);
8074                           printf ("  rdst = 0x%x\n", rdst);
8075                         }
8076                       SYNTAX("utof      %1%S1, %0");
8077 #line 1116 "rx-decode.opc"
8078                       ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
8079
8080                     }
8081                   break;
8082               }
8083             break;
8084           case 0x55:
8085               GETBYTE ();
8086               switch (op[2] & 0x00)
8087               {
8088                 case 0x00:
8089                   goto op_semantics_58;
8090                   break;
8091               }
8092             break;
8093           case 0x56:
8094               GETBYTE ();
8095               switch (op[2] & 0x00)
8096               {
8097                 case 0x00:
8098                   goto op_semantics_58;
8099                   break;
8100               }
8101             break;
8102           case 0x57:
8103               GETBYTE ();
8104               switch (op[2] & 0x00)
8105               {
8106                 case 0x00:
8107                   goto op_semantics_58;
8108                   break;
8109               }
8110             break;
8111           case 0x60:
8112               GETBYTE ();
8113               switch (op[2] & 0x00)
8114               {
8115                 case 0x00:
8116                   op_semantics_59:
8117                     {
8118                       /** 1111 1100 0110 00sd rdst rsrc bset    %1, %0%S0 */
8119 #line 942 "rx-decode.opc"
8120                       int sd AU = op[1] & 0x03;
8121 #line 942 "rx-decode.opc"
8122                       int rdst AU = (op[2] >> 4) & 0x0f;
8123 #line 942 "rx-decode.opc"
8124                       int rsrc AU = op[2] & 0x0f;
8125                       if (trace)
8126                         {
8127                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8128                                  "/** 1111 1100 0110 00sd rdst rsrc     bset    %1, %0%S0 */",
8129                                  op[0], op[1], op[2]);
8130                           printf ("  sd = 0x%x,", sd);
8131                           printf ("  rdst = 0x%x,", rdst);
8132                           printf ("  rsrc = 0x%x\n", rsrc);
8133                         }
8134                       SYNTAX("bset      %1, %0%S0");
8135 #line 942 "rx-decode.opc"
8136                       ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8137                       if (sd == 3) /* bset reg,reg */
8138                         BWL(LSIZE);
8139
8140                     }
8141                   break;
8142               }
8143             break;
8144           case 0x61:
8145               GETBYTE ();
8146               switch (op[2] & 0x00)
8147               {
8148                 case 0x00:
8149                   goto op_semantics_59;
8150                   break;
8151               }
8152             break;
8153           case 0x62:
8154               GETBYTE ();
8155               switch (op[2] & 0x00)
8156               {
8157                 case 0x00:
8158                   goto op_semantics_59;
8159                   break;
8160               }
8161             break;
8162           case 0x63:
8163               GETBYTE ();
8164               switch (op[2] & 0x00)
8165               {
8166                 case 0x00:
8167                   goto op_semantics_59;
8168                   break;
8169               }
8170             break;
8171           case 0x64:
8172               GETBYTE ();
8173               switch (op[2] & 0x00)
8174               {
8175                 case 0x00:
8176                   op_semantics_60:
8177                     {
8178                       /** 1111 1100 0110 01sd rdst rsrc bclr    %1, %0%S0 */
8179 #line 954 "rx-decode.opc"
8180                       int sd AU = op[1] & 0x03;
8181 #line 954 "rx-decode.opc"
8182                       int rdst AU = (op[2] >> 4) & 0x0f;
8183 #line 954 "rx-decode.opc"
8184                       int rsrc AU = op[2] & 0x0f;
8185                       if (trace)
8186                         {
8187                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8188                                  "/** 1111 1100 0110 01sd rdst rsrc     bclr    %1, %0%S0 */",
8189                                  op[0], op[1], op[2]);
8190                           printf ("  sd = 0x%x,", sd);
8191                           printf ("  rdst = 0x%x,", rdst);
8192                           printf ("  rsrc = 0x%x\n", rsrc);
8193                         }
8194                       SYNTAX("bclr      %1, %0%S0");
8195 #line 954 "rx-decode.opc"
8196                       ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8197                       if (sd == 3) /* bset reg,reg */
8198                         BWL(LSIZE);
8199
8200                     }
8201                   break;
8202               }
8203             break;
8204           case 0x65:
8205               GETBYTE ();
8206               switch (op[2] & 0x00)
8207               {
8208                 case 0x00:
8209                   goto op_semantics_60;
8210                   break;
8211               }
8212             break;
8213           case 0x66:
8214               GETBYTE ();
8215               switch (op[2] & 0x00)
8216               {
8217                 case 0x00:
8218                   goto op_semantics_60;
8219                   break;
8220               }
8221             break;
8222           case 0x67:
8223               GETBYTE ();
8224               switch (op[2] & 0x00)
8225               {
8226                 case 0x00:
8227                   goto op_semantics_60;
8228                   break;
8229               }
8230             break;
8231           case 0x68:
8232               GETBYTE ();
8233               switch (op[2] & 0x00)
8234               {
8235                 case 0x00:
8236                   op_semantics_61:
8237                     {
8238                       /** 1111 1100 0110 10sd rdst rsrc btst    %2, %1%S1 */
8239 #line 966 "rx-decode.opc"
8240                       int sd AU = op[1] & 0x03;
8241 #line 966 "rx-decode.opc"
8242                       int rdst AU = (op[2] >> 4) & 0x0f;
8243 #line 966 "rx-decode.opc"
8244                       int rsrc AU = op[2] & 0x0f;
8245                       if (trace)
8246                         {
8247                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8248                                  "/** 1111 1100 0110 10sd rdst rsrc     btst    %2, %1%S1 */",
8249                                  op[0], op[1], op[2]);
8250                           printf ("  sd = 0x%x,", sd);
8251                           printf ("  rdst = 0x%x,", rdst);
8252                           printf ("  rsrc = 0x%x\n", rsrc);
8253                         }
8254                       SYNTAX("btst      %2, %1%S1");
8255 #line 966 "rx-decode.opc"
8256                       ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
8257                       if (sd == 3) /* bset reg,reg */
8258                         BWL(LSIZE);
8259
8260                     }
8261                   break;
8262               }
8263             break;
8264           case 0x69:
8265               GETBYTE ();
8266               switch (op[2] & 0x00)
8267               {
8268                 case 0x00:
8269                   goto op_semantics_61;
8270                   break;
8271               }
8272             break;
8273           case 0x6a:
8274               GETBYTE ();
8275               switch (op[2] & 0x00)
8276               {
8277                 case 0x00:
8278                   goto op_semantics_61;
8279                   break;
8280               }
8281             break;
8282           case 0x6b:
8283               GETBYTE ();
8284               switch (op[2] & 0x00)
8285               {
8286                 case 0x00:
8287                   goto op_semantics_61;
8288                   break;
8289               }
8290             break;
8291           case 0x6c:
8292               GETBYTE ();
8293               switch (op[2] & 0x00)
8294               {
8295                 case 0x00:
8296                   op_semantics_62:
8297                     {
8298                       /** 1111 1100 0110 11sd rdst rsrc bnot    %1, %0%S0 */
8299 #line 978 "rx-decode.opc"
8300                       int sd AU = op[1] & 0x03;
8301 #line 978 "rx-decode.opc"
8302                       int rdst AU = (op[2] >> 4) & 0x0f;
8303 #line 978 "rx-decode.opc"
8304                       int rsrc AU = op[2] & 0x0f;
8305                       if (trace)
8306                         {
8307                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8308                                  "/** 1111 1100 0110 11sd rdst rsrc     bnot    %1, %0%S0 */",
8309                                  op[0], op[1], op[2]);
8310                           printf ("  sd = 0x%x,", sd);
8311                           printf ("  rdst = 0x%x,", rdst);
8312                           printf ("  rsrc = 0x%x\n", rsrc);
8313                         }
8314                       SYNTAX("bnot      %1, %0%S0");
8315 #line 978 "rx-decode.opc"
8316                       ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
8317                       if (sd == 3) /* bset reg,reg */
8318                         BWL(LSIZE);
8319
8320                     }
8321                   break;
8322               }
8323             break;
8324           case 0x6d:
8325               GETBYTE ();
8326               switch (op[2] & 0x00)
8327               {
8328                 case 0x00:
8329                   goto op_semantics_62;
8330                   break;
8331               }
8332             break;
8333           case 0x6e:
8334               GETBYTE ();
8335               switch (op[2] & 0x00)
8336               {
8337                 case 0x00:
8338                   goto op_semantics_62;
8339                   break;
8340               }
8341             break;
8342           case 0x6f:
8343               GETBYTE ();
8344               switch (op[2] & 0x00)
8345               {
8346                 case 0x00:
8347                   goto op_semantics_62;
8348                   break;
8349               }
8350             break;
8351           case 0x80:
8352               GETBYTE ();
8353               switch (op[2] & 0x00)
8354               {
8355                 case 0x00:
8356                   op_semantics_63:
8357                     {
8358                       /** 1111 1100 1000 00sd rsrc rdst fsub    %1%S1, %0 */
8359 #line 909 "rx-decode.opc"
8360                       int sd AU = op[1] & 0x03;
8361 #line 909 "rx-decode.opc"
8362                       int rsrc AU = (op[2] >> 4) & 0x0f;
8363 #line 909 "rx-decode.opc"
8364                       int rdst AU = op[2] & 0x0f;
8365                       if (trace)
8366                         {
8367                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8368                                  "/** 1111 1100 1000 00sd rsrc rdst     fsub    %1%S1, %0 */",
8369                                  op[0], op[1], op[2]);
8370                           printf ("  sd = 0x%x,", sd);
8371                           printf ("  rsrc = 0x%x,", rsrc);
8372                           printf ("  rdst = 0x%x\n", rdst);
8373                         }
8374                       SYNTAX("fsub      %1%S1, %0");
8375 #line 909 "rx-decode.opc"
8376                       ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8377
8378                     }
8379                   break;
8380               }
8381             break;
8382           case 0x81:
8383               GETBYTE ();
8384               switch (op[2] & 0x00)
8385               {
8386                 case 0x00:
8387                   goto op_semantics_63;
8388                   break;
8389               }
8390             break;
8391           case 0x82:
8392               GETBYTE ();
8393               switch (op[2] & 0x00)
8394               {
8395                 case 0x00:
8396                   goto op_semantics_63;
8397                   break;
8398               }
8399             break;
8400           case 0x83:
8401               GETBYTE ();
8402               switch (op[2] & 0x00)
8403               {
8404                 case 0x00:
8405                   goto op_semantics_63;
8406                   break;
8407               }
8408             break;
8409           case 0x84:
8410               GETBYTE ();
8411               switch (op[2] & 0x00)
8412               {
8413                 case 0x00:
8414                   op_semantics_64:
8415                     {
8416                       /** 1111 1100 1000 01sd rsrc rdst fcmp    %1%S1, %0 */
8417 #line 903 "rx-decode.opc"
8418                       int sd AU = op[1] & 0x03;
8419 #line 903 "rx-decode.opc"
8420                       int rsrc AU = (op[2] >> 4) & 0x0f;
8421 #line 903 "rx-decode.opc"
8422                       int rdst AU = op[2] & 0x0f;
8423                       if (trace)
8424                         {
8425                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8426                                  "/** 1111 1100 1000 01sd rsrc rdst     fcmp    %1%S1, %0 */",
8427                                  op[0], op[1], op[2]);
8428                           printf ("  sd = 0x%x,", sd);
8429                           printf ("  rsrc = 0x%x,", rsrc);
8430                           printf ("  rdst = 0x%x\n", rdst);
8431                         }
8432                       SYNTAX("fcmp      %1%S1, %0");
8433 #line 903 "rx-decode.opc"
8434                       ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
8435
8436                     }
8437                   break;
8438               }
8439             break;
8440           case 0x85:
8441               GETBYTE ();
8442               switch (op[2] & 0x00)
8443               {
8444                 case 0x00:
8445                   goto op_semantics_64;
8446                   break;
8447               }
8448             break;
8449           case 0x86:
8450               GETBYTE ();
8451               switch (op[2] & 0x00)
8452               {
8453                 case 0x00:
8454                   goto op_semantics_64;
8455                   break;
8456               }
8457             break;
8458           case 0x87:
8459               GETBYTE ();
8460               switch (op[2] & 0x00)
8461               {
8462                 case 0x00:
8463                   goto op_semantics_64;
8464                   break;
8465               }
8466             break;
8467           case 0x88:
8468               GETBYTE ();
8469               switch (op[2] & 0x00)
8470               {
8471                 case 0x00:
8472                   op_semantics_65:
8473                     {
8474                       /** 1111 1100 1000 10sd rsrc rdst fadd    %1%S1, %0 */
8475 #line 897 "rx-decode.opc"
8476                       int sd AU = op[1] & 0x03;
8477 #line 897 "rx-decode.opc"
8478                       int rsrc AU = (op[2] >> 4) & 0x0f;
8479 #line 897 "rx-decode.opc"
8480                       int rdst AU = op[2] & 0x0f;
8481                       if (trace)
8482                         {
8483                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8484                                  "/** 1111 1100 1000 10sd rsrc rdst     fadd    %1%S1, %0 */",
8485                                  op[0], op[1], op[2]);
8486                           printf ("  sd = 0x%x,", sd);
8487                           printf ("  rsrc = 0x%x,", rsrc);
8488                           printf ("  rdst = 0x%x\n", rdst);
8489                         }
8490                       SYNTAX("fadd      %1%S1, %0");
8491 #line 897 "rx-decode.opc"
8492                       ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8493
8494                     }
8495                   break;
8496               }
8497             break;
8498           case 0x89:
8499               GETBYTE ();
8500               switch (op[2] & 0x00)
8501               {
8502                 case 0x00:
8503                   goto op_semantics_65;
8504                   break;
8505               }
8506             break;
8507           case 0x8a:
8508               GETBYTE ();
8509               switch (op[2] & 0x00)
8510               {
8511                 case 0x00:
8512                   goto op_semantics_65;
8513                   break;
8514               }
8515             break;
8516           case 0x8b:
8517               GETBYTE ();
8518               switch (op[2] & 0x00)
8519               {
8520                 case 0x00:
8521                   goto op_semantics_65;
8522                   break;
8523               }
8524             break;
8525           case 0x8c:
8526               GETBYTE ();
8527               switch (op[2] & 0x00)
8528               {
8529                 case 0x00:
8530                   op_semantics_66:
8531                     {
8532                       /** 1111 1100 1000 11sd rsrc rdst fmul    %1%S1, %0 */
8533 #line 918 "rx-decode.opc"
8534                       int sd AU = op[1] & 0x03;
8535 #line 918 "rx-decode.opc"
8536                       int rsrc AU = (op[2] >> 4) & 0x0f;
8537 #line 918 "rx-decode.opc"
8538                       int rdst AU = op[2] & 0x0f;
8539                       if (trace)
8540                         {
8541                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8542                                  "/** 1111 1100 1000 11sd rsrc rdst     fmul    %1%S1, %0 */",
8543                                  op[0], op[1], op[2]);
8544                           printf ("  sd = 0x%x,", sd);
8545                           printf ("  rsrc = 0x%x,", rsrc);
8546                           printf ("  rdst = 0x%x\n", rdst);
8547                         }
8548                       SYNTAX("fmul      %1%S1, %0");
8549 #line 918 "rx-decode.opc"
8550                       ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8551
8552                     }
8553                   break;
8554               }
8555             break;
8556           case 0x8d:
8557               GETBYTE ();
8558               switch (op[2] & 0x00)
8559               {
8560                 case 0x00:
8561                   goto op_semantics_66;
8562                   break;
8563               }
8564             break;
8565           case 0x8e:
8566               GETBYTE ();
8567               switch (op[2] & 0x00)
8568               {
8569                 case 0x00:
8570                   goto op_semantics_66;
8571                   break;
8572               }
8573             break;
8574           case 0x8f:
8575               GETBYTE ();
8576               switch (op[2] & 0x00)
8577               {
8578                 case 0x00:
8579                   goto op_semantics_66;
8580                   break;
8581               }
8582             break;
8583           case 0x90:
8584               GETBYTE ();
8585               switch (op[2] & 0x00)
8586               {
8587                 case 0x00:
8588                   op_semantics_67:
8589                     {
8590                       /** 1111 1100 1001 00sd rsrc rdst fdiv    %1%S1, %0 */
8591 #line 924 "rx-decode.opc"
8592                       int sd AU = op[1] & 0x03;
8593 #line 924 "rx-decode.opc"
8594                       int rsrc AU = (op[2] >> 4) & 0x0f;
8595 #line 924 "rx-decode.opc"
8596                       int rdst AU = op[2] & 0x0f;
8597                       if (trace)
8598                         {
8599                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8600                                  "/** 1111 1100 1001 00sd rsrc rdst     fdiv    %1%S1, %0 */",
8601                                  op[0], op[1], op[2]);
8602                           printf ("  sd = 0x%x,", sd);
8603                           printf ("  rsrc = 0x%x,", rsrc);
8604                           printf ("  rdst = 0x%x\n", rdst);
8605                         }
8606                       SYNTAX("fdiv      %1%S1, %0");
8607 #line 924 "rx-decode.opc"
8608                       ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8609
8610                     }
8611                   break;
8612               }
8613             break;
8614           case 0x91:
8615               GETBYTE ();
8616               switch (op[2] & 0x00)
8617               {
8618                 case 0x00:
8619                   goto op_semantics_67;
8620                   break;
8621               }
8622             break;
8623           case 0x92:
8624               GETBYTE ();
8625               switch (op[2] & 0x00)
8626               {
8627                 case 0x00:
8628                   goto op_semantics_67;
8629                   break;
8630               }
8631             break;
8632           case 0x93:
8633               GETBYTE ();
8634               switch (op[2] & 0x00)
8635               {
8636                 case 0x00:
8637                   goto op_semantics_67;
8638                   break;
8639               }
8640             break;
8641           case 0x94:
8642               GETBYTE ();
8643               switch (op[2] & 0x00)
8644               {
8645                 case 0x00:
8646                   op_semantics_68:
8647                     {
8648                       /** 1111 1100 1001 01sd rsrc rdst ftoi    %1%S1, %0 */
8649 #line 912 "rx-decode.opc"
8650                       int sd AU = op[1] & 0x03;
8651 #line 912 "rx-decode.opc"
8652                       int rsrc AU = (op[2] >> 4) & 0x0f;
8653 #line 912 "rx-decode.opc"
8654                       int rdst AU = op[2] & 0x0f;
8655                       if (trace)
8656                         {
8657                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8658                                  "/** 1111 1100 1001 01sd rsrc rdst     ftoi    %1%S1, %0 */",
8659                                  op[0], op[1], op[2]);
8660                           printf ("  sd = 0x%x,", sd);
8661                           printf ("  rsrc = 0x%x,", rsrc);
8662                           printf ("  rdst = 0x%x\n", rdst);
8663                         }
8664                       SYNTAX("ftoi      %1%S1, %0");
8665 #line 912 "rx-decode.opc"
8666                       ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8667
8668                     }
8669                   break;
8670               }
8671             break;
8672           case 0x95:
8673               GETBYTE ();
8674               switch (op[2] & 0x00)
8675               {
8676                 case 0x00:
8677                   goto op_semantics_68;
8678                   break;
8679               }
8680             break;
8681           case 0x96:
8682               GETBYTE ();
8683               switch (op[2] & 0x00)
8684               {
8685                 case 0x00:
8686                   goto op_semantics_68;
8687                   break;
8688               }
8689             break;
8690           case 0x97:
8691               GETBYTE ();
8692               switch (op[2] & 0x00)
8693               {
8694                 case 0x00:
8695                   goto op_semantics_68;
8696                   break;
8697               }
8698             break;
8699           case 0x98:
8700               GETBYTE ();
8701               switch (op[2] & 0x00)
8702               {
8703                 case 0x00:
8704                   op_semantics_69:
8705                     {
8706                       /** 1111 1100 1001 10sd rsrc rdst round   %1%S1, %0 */
8707 #line 927 "rx-decode.opc"
8708                       int sd AU = op[1] & 0x03;
8709 #line 927 "rx-decode.opc"
8710                       int rsrc AU = (op[2] >> 4) & 0x0f;
8711 #line 927 "rx-decode.opc"
8712                       int rdst AU = op[2] & 0x0f;
8713                       if (trace)
8714                         {
8715                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8716                                  "/** 1111 1100 1001 10sd rsrc rdst     round   %1%S1, %0 */",
8717                                  op[0], op[1], op[2]);
8718                           printf ("  sd = 0x%x,", sd);
8719                           printf ("  rsrc = 0x%x,", rsrc);
8720                           printf ("  rdst = 0x%x\n", rdst);
8721                         }
8722                       SYNTAX("round     %1%S1, %0");
8723 #line 927 "rx-decode.opc"
8724                       ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8725
8726                     }
8727                   break;
8728               }
8729             break;
8730           case 0x99:
8731               GETBYTE ();
8732               switch (op[2] & 0x00)
8733               {
8734                 case 0x00:
8735                   goto op_semantics_69;
8736                   break;
8737               }
8738             break;
8739           case 0x9a:
8740               GETBYTE ();
8741               switch (op[2] & 0x00)
8742               {
8743                 case 0x00:
8744                   goto op_semantics_69;
8745                   break;
8746               }
8747             break;
8748           case 0x9b:
8749               GETBYTE ();
8750               switch (op[2] & 0x00)
8751               {
8752                 case 0x00:
8753                   goto op_semantics_69;
8754                   break;
8755               }
8756             break;
8757           case 0xa0:
8758               GETBYTE ();
8759               switch (op[2] & 0x00)
8760               {
8761                 case 0x00:
8762                   op_semantics_70:
8763                     {
8764                       /** 1111 1100 1010 00sd rsrc rdst fsqrt   %1%S1, %0 */
8765 #line 1110 "rx-decode.opc"
8766                       int sd AU = op[1] & 0x03;
8767 #line 1110 "rx-decode.opc"
8768                       int rsrc AU = (op[2] >> 4) & 0x0f;
8769 #line 1110 "rx-decode.opc"
8770                       int rdst AU = op[2] & 0x0f;
8771                       if (trace)
8772                         {
8773                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8774                                  "/** 1111 1100 1010 00sd rsrc rdst     fsqrt   %1%S1, %0 */",
8775                                  op[0], op[1], op[2]);
8776                           printf ("  sd = 0x%x,", sd);
8777                           printf ("  rsrc = 0x%x,", rsrc);
8778                           printf ("  rdst = 0x%x\n", rdst);
8779                         }
8780                       SYNTAX("fsqrt     %1%S1, %0");
8781 #line 1110 "rx-decode.opc"
8782                       ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8783
8784                     }
8785                   break;
8786               }
8787             break;
8788           case 0xa1:
8789               GETBYTE ();
8790               switch (op[2] & 0x00)
8791               {
8792                 case 0x00:
8793                   goto op_semantics_70;
8794                   break;
8795               }
8796             break;
8797           case 0xa2:
8798               GETBYTE ();
8799               switch (op[2] & 0x00)
8800               {
8801                 case 0x00:
8802                   goto op_semantics_70;
8803                   break;
8804               }
8805             break;
8806           case 0xa3:
8807               GETBYTE ();
8808               switch (op[2] & 0x00)
8809               {
8810                 case 0x00:
8811                   goto op_semantics_70;
8812                   break;
8813               }
8814             break;
8815           case 0xa4:
8816               GETBYTE ();
8817               switch (op[2] & 0x00)
8818               {
8819                 case 0x00:
8820                   op_semantics_71:
8821                     {
8822                       /** 1111 1100 1010 01sd rsrc rdst ftou    %1%S1, %0 */
8823 #line 1113 "rx-decode.opc"
8824                       int sd AU = op[1] & 0x03;
8825 #line 1113 "rx-decode.opc"
8826                       int rsrc AU = (op[2] >> 4) & 0x0f;
8827 #line 1113 "rx-decode.opc"
8828                       int rdst AU = op[2] & 0x0f;
8829                       if (trace)
8830                         {
8831                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8832                                  "/** 1111 1100 1010 01sd rsrc rdst     ftou    %1%S1, %0 */",
8833                                  op[0], op[1], op[2]);
8834                           printf ("  sd = 0x%x,", sd);
8835                           printf ("  rsrc = 0x%x,", rsrc);
8836                           printf ("  rdst = 0x%x\n", rdst);
8837                         }
8838                       SYNTAX("ftou      %1%S1, %0");
8839 #line 1113 "rx-decode.opc"
8840                       ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8841
8842                     }
8843                   break;
8844               }
8845             break;
8846           case 0xa5:
8847               GETBYTE ();
8848               switch (op[2] & 0x00)
8849               {
8850                 case 0x00:
8851                   goto op_semantics_71;
8852                   break;
8853               }
8854             break;
8855           case 0xa6:
8856               GETBYTE ();
8857               switch (op[2] & 0x00)
8858               {
8859                 case 0x00:
8860                   goto op_semantics_71;
8861                   break;
8862               }
8863             break;
8864           case 0xa7:
8865               GETBYTE ();
8866               switch (op[2] & 0x00)
8867               {
8868                 case 0x00:
8869                   goto op_semantics_71;
8870                   break;
8871               }
8872             break;
8873           case 0xd0:
8874               GETBYTE ();
8875               switch (op[2] & 0x00)
8876               {
8877                 case 0x00:
8878                   op_semantics_72:
8879                     {
8880                       /** 1111 1100 1101 sz sd rdst cond        sc%1%s  %0 */
8881 #line 1044 "rx-decode.opc"
8882                       int sz AU = (op[1] >> 2) & 0x03;
8883 #line 1044 "rx-decode.opc"
8884                       int sd AU = op[1] & 0x03;
8885 #line 1044 "rx-decode.opc"
8886                       int rdst AU = (op[2] >> 4) & 0x0f;
8887 #line 1044 "rx-decode.opc"
8888                       int cond AU = op[2] & 0x0f;
8889                       if (trace)
8890                         {
8891                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8892                                  "/** 1111 1100 1101 sz sd rdst cond    sc%1%s  %0 */",
8893                                  op[0], op[1], op[2]);
8894                           printf ("  sz = 0x%x,", sz);
8895                           printf ("  sd = 0x%x,", sd);
8896                           printf ("  rdst = 0x%x,", rdst);
8897                           printf ("  cond = 0x%x\n", cond);
8898                         }
8899                       SYNTAX("sc%1%s    %0");
8900 #line 1044 "rx-decode.opc"
8901                       ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8902
8903                     /*----------------------------------------------------------------------*/
8904                     /* RXv2 enhanced                                                            */
8905
8906                     }
8907                   break;
8908               }
8909             break;
8910           case 0xd1:
8911               GETBYTE ();
8912               switch (op[2] & 0x00)
8913               {
8914                 case 0x00:
8915                   goto op_semantics_72;
8916                   break;
8917               }
8918             break;
8919           case 0xd2:
8920               GETBYTE ();
8921               switch (op[2] & 0x00)
8922               {
8923                 case 0x00:
8924                   goto op_semantics_72;
8925                   break;
8926               }
8927             break;
8928           case 0xd3:
8929               GETBYTE ();
8930               switch (op[2] & 0x00)
8931               {
8932                 case 0x00:
8933                   goto op_semantics_72;
8934                   break;
8935               }
8936             break;
8937           case 0xd4:
8938               GETBYTE ();
8939               switch (op[2] & 0x00)
8940               {
8941                 case 0x00:
8942                   goto op_semantics_72;
8943                   break;
8944               }
8945             break;
8946           case 0xd5:
8947               GETBYTE ();
8948               switch (op[2] & 0x00)
8949               {
8950                 case 0x00:
8951                   goto op_semantics_72;
8952                   break;
8953               }
8954             break;
8955           case 0xd6:
8956               GETBYTE ();
8957               switch (op[2] & 0x00)
8958               {
8959                 case 0x00:
8960                   goto op_semantics_72;
8961                   break;
8962               }
8963             break;
8964           case 0xd7:
8965               GETBYTE ();
8966               switch (op[2] & 0x00)
8967               {
8968                 case 0x00:
8969                   goto op_semantics_72;
8970                   break;
8971               }
8972             break;
8973           case 0xd8:
8974               GETBYTE ();
8975               switch (op[2] & 0x00)
8976               {
8977                 case 0x00:
8978                   goto op_semantics_72;
8979                   break;
8980               }
8981             break;
8982           case 0xd9:
8983               GETBYTE ();
8984               switch (op[2] & 0x00)
8985               {
8986                 case 0x00:
8987                   goto op_semantics_72;
8988                   break;
8989               }
8990             break;
8991           case 0xda:
8992               GETBYTE ();
8993               switch (op[2] & 0x00)
8994               {
8995                 case 0x00:
8996                   goto op_semantics_72;
8997                   break;
8998               }
8999             break;
9000           case 0xdb:
9001               GETBYTE ();
9002               switch (op[2] & 0x00)
9003               {
9004                 case 0x00:
9005                   goto op_semantics_72;
9006                   break;
9007               }
9008             break;
9009           case 0xe0:
9010               GETBYTE ();
9011               switch (op[2] & 0x0f)
9012               {
9013                 case 0x00:
9014                 case 0x01:
9015                 case 0x02:
9016                 case 0x03:
9017                 case 0x04:
9018                 case 0x05:
9019                 case 0x06:
9020                 case 0x07:
9021                 case 0x08:
9022                 case 0x09:
9023                 case 0x0a:
9024                 case 0x0b:
9025                 case 0x0c:
9026                 case 0x0d:
9027                 case 0x0e:
9028                   op_semantics_73:
9029                     {
9030                       /** 1111 1100 111bit sd rdst cond bm%2    #%1, %0%S0 */
9031 #line 987 "rx-decode.opc"
9032                       int bit AU = (op[1] >> 2) & 0x07;
9033 #line 987 "rx-decode.opc"
9034                       int sd AU = op[1] & 0x03;
9035 #line 987 "rx-decode.opc"
9036                       int rdst AU = (op[2] >> 4) & 0x0f;
9037 #line 987 "rx-decode.opc"
9038                       int cond AU = op[2] & 0x0f;
9039                       if (trace)
9040                         {
9041                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9042                                  "/** 1111 1100 111bit sd rdst cond     bm%2    #%1, %0%S0 */",
9043                                  op[0], op[1], op[2]);
9044                           printf ("  bit = 0x%x,", bit);
9045                           printf ("  sd = 0x%x,", sd);
9046                           printf ("  rdst = 0x%x,", rdst);
9047                           printf ("  cond = 0x%x\n", cond);
9048                         }
9049                       SYNTAX("bm%2      #%1, %0%S0");
9050 #line 987 "rx-decode.opc"
9051                       ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
9052
9053                     }
9054                   break;
9055                 case 0x0f:
9056                   op_semantics_74:
9057                     {
9058                       /** 1111 1100 111bit sd rdst 1111 bnot    #%1, %0%S0 */
9059 #line 975 "rx-decode.opc"
9060                       int bit AU = (op[1] >> 2) & 0x07;
9061 #line 975 "rx-decode.opc"
9062                       int sd AU = op[1] & 0x03;
9063 #line 975 "rx-decode.opc"
9064                       int rdst AU = (op[2] >> 4) & 0x0f;
9065                       if (trace)
9066                         {
9067                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9068                                  "/** 1111 1100 111bit sd rdst 1111     bnot    #%1, %0%S0 */",
9069                                  op[0], op[1], op[2]);
9070                           printf ("  bit = 0x%x,", bit);
9071                           printf ("  sd = 0x%x,", sd);
9072                           printf ("  rdst = 0x%x\n", rdst);
9073                         }
9074                       SYNTAX("bnot      #%1, %0%S0");
9075 #line 975 "rx-decode.opc"
9076                       ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
9077
9078                     }
9079                   break;
9080               }
9081             break;
9082           case 0xe1:
9083               GETBYTE ();
9084               switch (op[2] & 0x0f)
9085               {
9086                 case 0x00:
9087                 case 0x01:
9088                 case 0x02:
9089                 case 0x03:
9090                 case 0x04:
9091                 case 0x05:
9092                 case 0x06:
9093                 case 0x07:
9094                 case 0x08:
9095                 case 0x09:
9096                 case 0x0a:
9097                 case 0x0b:
9098                 case 0x0c:
9099                 case 0x0d:
9100                 case 0x0e:
9101                   goto op_semantics_73;
9102                   break;
9103                 case 0x0f:
9104                   goto op_semantics_74;
9105                   break;
9106               }
9107             break;
9108           case 0xe2:
9109               GETBYTE ();
9110               switch (op[2] & 0x0f)
9111               {
9112                 case 0x00:
9113                 case 0x01:
9114                 case 0x02:
9115                 case 0x03:
9116                 case 0x04:
9117                 case 0x05:
9118                 case 0x06:
9119                 case 0x07:
9120                 case 0x08:
9121                 case 0x09:
9122                 case 0x0a:
9123                 case 0x0b:
9124                 case 0x0c:
9125                 case 0x0d:
9126                 case 0x0e:
9127                   goto op_semantics_73;
9128                   break;
9129                 case 0x0f:
9130                   goto op_semantics_74;
9131                   break;
9132               }
9133             break;
9134           case 0xe3:
9135               GETBYTE ();
9136               switch (op[2] & 0x0f)
9137               {
9138                 case 0x00:
9139                 case 0x01:
9140                 case 0x02:
9141                 case 0x03:
9142                 case 0x04:
9143                 case 0x05:
9144                 case 0x06:
9145                 case 0x07:
9146                 case 0x08:
9147                 case 0x09:
9148                 case 0x0a:
9149                 case 0x0b:
9150                 case 0x0c:
9151                 case 0x0d:
9152                 case 0x0e:
9153                   goto op_semantics_73;
9154                   break;
9155                 case 0x0f:
9156                   goto op_semantics_74;
9157                   break;
9158               }
9159             break;
9160           case 0xe4:
9161               GETBYTE ();
9162               switch (op[2] & 0x0f)
9163               {
9164                 case 0x00:
9165                 case 0x01:
9166                 case 0x02:
9167                 case 0x03:
9168                 case 0x04:
9169                 case 0x05:
9170                 case 0x06:
9171                 case 0x07:
9172                 case 0x08:
9173                 case 0x09:
9174                 case 0x0a:
9175                 case 0x0b:
9176                 case 0x0c:
9177                 case 0x0d:
9178                 case 0x0e:
9179                   goto op_semantics_73;
9180                   break;
9181                 case 0x0f:
9182                   goto op_semantics_74;
9183                   break;
9184               }
9185             break;
9186           case 0xe5:
9187               GETBYTE ();
9188               switch (op[2] & 0x0f)
9189               {
9190                 case 0x00:
9191                 case 0x01:
9192                 case 0x02:
9193                 case 0x03:
9194                 case 0x04:
9195                 case 0x05:
9196                 case 0x06:
9197                 case 0x07:
9198                 case 0x08:
9199                 case 0x09:
9200                 case 0x0a:
9201                 case 0x0b:
9202                 case 0x0c:
9203                 case 0x0d:
9204                 case 0x0e:
9205                   goto op_semantics_73;
9206                   break;
9207                 case 0x0f:
9208                   goto op_semantics_74;
9209                   break;
9210               }
9211             break;
9212           case 0xe6:
9213               GETBYTE ();
9214               switch (op[2] & 0x0f)
9215               {
9216                 case 0x00:
9217                 case 0x01:
9218                 case 0x02:
9219                 case 0x03:
9220                 case 0x04:
9221                 case 0x05:
9222                 case 0x06:
9223                 case 0x07:
9224                 case 0x08:
9225                 case 0x09:
9226                 case 0x0a:
9227                 case 0x0b:
9228                 case 0x0c:
9229                 case 0x0d:
9230                 case 0x0e:
9231                   goto op_semantics_73;
9232                   break;
9233                 case 0x0f:
9234                   goto op_semantics_74;
9235                   break;
9236               }
9237             break;
9238           case 0xe7:
9239               GETBYTE ();
9240               switch (op[2] & 0x0f)
9241               {
9242                 case 0x00:
9243                 case 0x01:
9244                 case 0x02:
9245                 case 0x03:
9246                 case 0x04:
9247                 case 0x05:
9248                 case 0x06:
9249                 case 0x07:
9250                 case 0x08:
9251                 case 0x09:
9252                 case 0x0a:
9253                 case 0x0b:
9254                 case 0x0c:
9255                 case 0x0d:
9256                 case 0x0e:
9257                   goto op_semantics_73;
9258                   break;
9259                 case 0x0f:
9260                   goto op_semantics_74;
9261                   break;
9262               }
9263             break;
9264           case 0xe8:
9265               GETBYTE ();
9266               switch (op[2] & 0x0f)
9267               {
9268                 case 0x00:
9269                 case 0x01:
9270                 case 0x02:
9271                 case 0x03:
9272                 case 0x04:
9273                 case 0x05:
9274                 case 0x06:
9275                 case 0x07:
9276                 case 0x08:
9277                 case 0x09:
9278                 case 0x0a:
9279                 case 0x0b:
9280                 case 0x0c:
9281                 case 0x0d:
9282                 case 0x0e:
9283                   goto op_semantics_73;
9284                   break;
9285                 case 0x0f:
9286                   goto op_semantics_74;
9287                   break;
9288               }
9289             break;
9290           case 0xe9:
9291               GETBYTE ();
9292               switch (op[2] & 0x0f)
9293               {
9294                 case 0x00:
9295                 case 0x01:
9296                 case 0x02:
9297                 case 0x03:
9298                 case 0x04:
9299                 case 0x05:
9300                 case 0x06:
9301                 case 0x07:
9302                 case 0x08:
9303                 case 0x09:
9304                 case 0x0a:
9305                 case 0x0b:
9306                 case 0x0c:
9307                 case 0x0d:
9308                 case 0x0e:
9309                   goto op_semantics_73;
9310                   break;
9311                 case 0x0f:
9312                   goto op_semantics_74;
9313                   break;
9314               }
9315             break;
9316           case 0xea:
9317               GETBYTE ();
9318               switch (op[2] & 0x0f)
9319               {
9320                 case 0x00:
9321                 case 0x01:
9322                 case 0x02:
9323                 case 0x03:
9324                 case 0x04:
9325                 case 0x05:
9326                 case 0x06:
9327                 case 0x07:
9328                 case 0x08:
9329                 case 0x09:
9330                 case 0x0a:
9331                 case 0x0b:
9332                 case 0x0c:
9333                 case 0x0d:
9334                 case 0x0e:
9335                   goto op_semantics_73;
9336                   break;
9337                 case 0x0f:
9338                   goto op_semantics_74;
9339                   break;
9340               }
9341             break;
9342           case 0xeb:
9343               GETBYTE ();
9344               switch (op[2] & 0x0f)
9345               {
9346                 case 0x00:
9347                 case 0x01:
9348                 case 0x02:
9349                 case 0x03:
9350                 case 0x04:
9351                 case 0x05:
9352                 case 0x06:
9353                 case 0x07:
9354                 case 0x08:
9355                 case 0x09:
9356                 case 0x0a:
9357                 case 0x0b:
9358                 case 0x0c:
9359                 case 0x0d:
9360                 case 0x0e:
9361                   goto op_semantics_73;
9362                   break;
9363                 case 0x0f:
9364                   goto op_semantics_74;
9365                   break;
9366               }
9367             break;
9368           case 0xec:
9369               GETBYTE ();
9370               switch (op[2] & 0x0f)
9371               {
9372                 case 0x00:
9373                 case 0x01:
9374                 case 0x02:
9375                 case 0x03:
9376                 case 0x04:
9377                 case 0x05:
9378                 case 0x06:
9379                 case 0x07:
9380                 case 0x08:
9381                 case 0x09:
9382                 case 0x0a:
9383                 case 0x0b:
9384                 case 0x0c:
9385                 case 0x0d:
9386                 case 0x0e:
9387                   goto op_semantics_73;
9388                   break;
9389                 case 0x0f:
9390                   goto op_semantics_74;
9391                   break;
9392               }
9393             break;
9394           case 0xed:
9395               GETBYTE ();
9396               switch (op[2] & 0x0f)
9397               {
9398                 case 0x00:
9399                 case 0x01:
9400                 case 0x02:
9401                 case 0x03:
9402                 case 0x04:
9403                 case 0x05:
9404                 case 0x06:
9405                 case 0x07:
9406                 case 0x08:
9407                 case 0x09:
9408                 case 0x0a:
9409                 case 0x0b:
9410                 case 0x0c:
9411                 case 0x0d:
9412                 case 0x0e:
9413                   goto op_semantics_73;
9414                   break;
9415                 case 0x0f:
9416                   goto op_semantics_74;
9417                   break;
9418               }
9419             break;
9420           case 0xee:
9421               GETBYTE ();
9422               switch (op[2] & 0x0f)
9423               {
9424                 case 0x00:
9425                 case 0x01:
9426                 case 0x02:
9427                 case 0x03:
9428                 case 0x04:
9429                 case 0x05:
9430                 case 0x06:
9431                 case 0x07:
9432                 case 0x08:
9433                 case 0x09:
9434                 case 0x0a:
9435                 case 0x0b:
9436                 case 0x0c:
9437                 case 0x0d:
9438                 case 0x0e:
9439                   goto op_semantics_73;
9440                   break;
9441                 case 0x0f:
9442                   goto op_semantics_74;
9443                   break;
9444               }
9445             break;
9446           case 0xef:
9447               GETBYTE ();
9448               switch (op[2] & 0x0f)
9449               {
9450                 case 0x00:
9451                 case 0x01:
9452                 case 0x02:
9453                 case 0x03:
9454                 case 0x04:
9455                 case 0x05:
9456                 case 0x06:
9457                 case 0x07:
9458                 case 0x08:
9459                 case 0x09:
9460                 case 0x0a:
9461                 case 0x0b:
9462                 case 0x0c:
9463                 case 0x0d:
9464                 case 0x0e:
9465                   goto op_semantics_73;
9466                   break;
9467                 case 0x0f:
9468                   goto op_semantics_74;
9469                   break;
9470               }
9471             break;
9472           case 0xf0:
9473               GETBYTE ();
9474               switch (op[2] & 0x0f)
9475               {
9476                 case 0x00:
9477                 case 0x01:
9478                 case 0x02:
9479                 case 0x03:
9480                 case 0x04:
9481                 case 0x05:
9482                 case 0x06:
9483                 case 0x07:
9484                 case 0x08:
9485                 case 0x09:
9486                 case 0x0a:
9487                 case 0x0b:
9488                 case 0x0c:
9489                 case 0x0d:
9490                 case 0x0e:
9491                   goto op_semantics_73;
9492                   break;
9493                 case 0x0f:
9494                   goto op_semantics_74;
9495                   break;
9496               }
9497             break;
9498           case 0xf1:
9499               GETBYTE ();
9500               switch (op[2] & 0x0f)
9501               {
9502                 case 0x00:
9503                 case 0x01:
9504                 case 0x02:
9505                 case 0x03:
9506                 case 0x04:
9507                 case 0x05:
9508                 case 0x06:
9509                 case 0x07:
9510                 case 0x08:
9511                 case 0x09:
9512                 case 0x0a:
9513                 case 0x0b:
9514                 case 0x0c:
9515                 case 0x0d:
9516                 case 0x0e:
9517                   goto op_semantics_73;
9518                   break;
9519                 case 0x0f:
9520                   goto op_semantics_74;
9521                   break;
9522               }
9523             break;
9524           case 0xf2:
9525               GETBYTE ();
9526               switch (op[2] & 0x0f)
9527               {
9528                 case 0x00:
9529                 case 0x01:
9530                 case 0x02:
9531                 case 0x03:
9532                 case 0x04:
9533                 case 0x05:
9534                 case 0x06:
9535                 case 0x07:
9536                 case 0x08:
9537                 case 0x09:
9538                 case 0x0a:
9539                 case 0x0b:
9540                 case 0x0c:
9541                 case 0x0d:
9542                 case 0x0e:
9543                   goto op_semantics_73;
9544                   break;
9545                 case 0x0f:
9546                   goto op_semantics_74;
9547                   break;
9548               }
9549             break;
9550           case 0xf3:
9551               GETBYTE ();
9552               switch (op[2] & 0x0f)
9553               {
9554                 case 0x00:
9555                 case 0x01:
9556                 case 0x02:
9557                 case 0x03:
9558                 case 0x04:
9559                 case 0x05:
9560                 case 0x06:
9561                 case 0x07:
9562                 case 0x08:
9563                 case 0x09:
9564                 case 0x0a:
9565                 case 0x0b:
9566                 case 0x0c:
9567                 case 0x0d:
9568                 case 0x0e:
9569                   goto op_semantics_73;
9570                   break;
9571                 case 0x0f:
9572                   goto op_semantics_74;
9573                   break;
9574               }
9575             break;
9576           case 0xf4:
9577               GETBYTE ();
9578               switch (op[2] & 0x0f)
9579               {
9580                 case 0x00:
9581                 case 0x01:
9582                 case 0x02:
9583                 case 0x03:
9584                 case 0x04:
9585                 case 0x05:
9586                 case 0x06:
9587                 case 0x07:
9588                 case 0x08:
9589                 case 0x09:
9590                 case 0x0a:
9591                 case 0x0b:
9592                 case 0x0c:
9593                 case 0x0d:
9594                 case 0x0e:
9595                   goto op_semantics_73;
9596                   break;
9597                 case 0x0f:
9598                   goto op_semantics_74;
9599                   break;
9600               }
9601             break;
9602           case 0xf5:
9603               GETBYTE ();
9604               switch (op[2] & 0x0f)
9605               {
9606                 case 0x00:
9607                 case 0x01:
9608                 case 0x02:
9609                 case 0x03:
9610                 case 0x04:
9611                 case 0x05:
9612                 case 0x06:
9613                 case 0x07:
9614                 case 0x08:
9615                 case 0x09:
9616                 case 0x0a:
9617                 case 0x0b:
9618                 case 0x0c:
9619                 case 0x0d:
9620                 case 0x0e:
9621                   goto op_semantics_73;
9622                   break;
9623                 case 0x0f:
9624                   goto op_semantics_74;
9625                   break;
9626               }
9627             break;
9628           case 0xf6:
9629               GETBYTE ();
9630               switch (op[2] & 0x0f)
9631               {
9632                 case 0x00:
9633                 case 0x01:
9634                 case 0x02:
9635                 case 0x03:
9636                 case 0x04:
9637                 case 0x05:
9638                 case 0x06:
9639                 case 0x07:
9640                 case 0x08:
9641                 case 0x09:
9642                 case 0x0a:
9643                 case 0x0b:
9644                 case 0x0c:
9645                 case 0x0d:
9646                 case 0x0e:
9647                   goto op_semantics_73;
9648                   break;
9649                 case 0x0f:
9650                   goto op_semantics_74;
9651                   break;
9652               }
9653             break;
9654           case 0xf7:
9655               GETBYTE ();
9656               switch (op[2] & 0x0f)
9657               {
9658                 case 0x00:
9659                 case 0x01:
9660                 case 0x02:
9661                 case 0x03:
9662                 case 0x04:
9663                 case 0x05:
9664                 case 0x06:
9665                 case 0x07:
9666                 case 0x08:
9667                 case 0x09:
9668                 case 0x0a:
9669                 case 0x0b:
9670                 case 0x0c:
9671                 case 0x0d:
9672                 case 0x0e:
9673                   goto op_semantics_73;
9674                   break;
9675                 case 0x0f:
9676                   goto op_semantics_74;
9677                   break;
9678               }
9679             break;
9680           case 0xf8:
9681               GETBYTE ();
9682               switch (op[2] & 0x0f)
9683               {
9684                 case 0x00:
9685                 case 0x01:
9686                 case 0x02:
9687                 case 0x03:
9688                 case 0x04:
9689                 case 0x05:
9690                 case 0x06:
9691                 case 0x07:
9692                 case 0x08:
9693                 case 0x09:
9694                 case 0x0a:
9695                 case 0x0b:
9696                 case 0x0c:
9697                 case 0x0d:
9698                 case 0x0e:
9699                   goto op_semantics_73;
9700                   break;
9701                 case 0x0f:
9702                   goto op_semantics_74;
9703                   break;
9704               }
9705             break;
9706           case 0xf9:
9707               GETBYTE ();
9708               switch (op[2] & 0x0f)
9709               {
9710                 case 0x00:
9711                 case 0x01:
9712                 case 0x02:
9713                 case 0x03:
9714                 case 0x04:
9715                 case 0x05:
9716                 case 0x06:
9717                 case 0x07:
9718                 case 0x08:
9719                 case 0x09:
9720                 case 0x0a:
9721                 case 0x0b:
9722                 case 0x0c:
9723                 case 0x0d:
9724                 case 0x0e:
9725                   goto op_semantics_73;
9726                   break;
9727                 case 0x0f:
9728                   goto op_semantics_74;
9729                   break;
9730               }
9731             break;
9732           case 0xfa:
9733               GETBYTE ();
9734               switch (op[2] & 0x0f)
9735               {
9736                 case 0x00:
9737                 case 0x01:
9738                 case 0x02:
9739                 case 0x03:
9740                 case 0x04:
9741                 case 0x05:
9742                 case 0x06:
9743                 case 0x07:
9744                 case 0x08:
9745                 case 0x09:
9746                 case 0x0a:
9747                 case 0x0b:
9748                 case 0x0c:
9749                 case 0x0d:
9750                 case 0x0e:
9751                   goto op_semantics_73;
9752                   break;
9753                 case 0x0f:
9754                   goto op_semantics_74;
9755                   break;
9756               }
9757             break;
9758           case 0xfb:
9759               GETBYTE ();
9760               switch (op[2] & 0x0f)
9761               {
9762                 case 0x00:
9763                 case 0x01:
9764                 case 0x02:
9765                 case 0x03:
9766                 case 0x04:
9767                 case 0x05:
9768                 case 0x06:
9769                 case 0x07:
9770                 case 0x08:
9771                 case 0x09:
9772                 case 0x0a:
9773                 case 0x0b:
9774                 case 0x0c:
9775                 case 0x0d:
9776                 case 0x0e:
9777                   goto op_semantics_73;
9778                   break;
9779                 case 0x0f:
9780                   goto op_semantics_74;
9781                   break;
9782               }
9783             break;
9784           case 0xfc:
9785               GETBYTE ();
9786               switch (op[2] & 0x0f)
9787               {
9788                 case 0x00:
9789                 case 0x01:
9790                 case 0x02:
9791                 case 0x03:
9792                 case 0x04:
9793                 case 0x05:
9794                 case 0x06:
9795                 case 0x07:
9796                 case 0x08:
9797                 case 0x09:
9798                 case 0x0a:
9799                 case 0x0b:
9800                 case 0x0c:
9801                 case 0x0d:
9802                 case 0x0e:
9803                   goto op_semantics_73;
9804                   break;
9805                 case 0x0f:
9806                   goto op_semantics_74;
9807                   break;
9808               }
9809             break;
9810           case 0xfd:
9811               GETBYTE ();
9812               switch (op[2] & 0x0f)
9813               {
9814                 case 0x00:
9815                 case 0x01:
9816                 case 0x02:
9817                 case 0x03:
9818                 case 0x04:
9819                 case 0x05:
9820                 case 0x06:
9821                 case 0x07:
9822                 case 0x08:
9823                 case 0x09:
9824                 case 0x0a:
9825                 case 0x0b:
9826                 case 0x0c:
9827                 case 0x0d:
9828                 case 0x0e:
9829                   goto op_semantics_73;
9830                   break;
9831                 case 0x0f:
9832                   goto op_semantics_74;
9833                   break;
9834               }
9835             break;
9836           case 0xfe:
9837               GETBYTE ();
9838               switch (op[2] & 0x0f)
9839               {
9840                 case 0x00:
9841                 case 0x01:
9842                 case 0x02:
9843                 case 0x03:
9844                 case 0x04:
9845                 case 0x05:
9846                 case 0x06:
9847                 case 0x07:
9848                 case 0x08:
9849                 case 0x09:
9850                 case 0x0a:
9851                 case 0x0b:
9852                 case 0x0c:
9853                 case 0x0d:
9854                 case 0x0e:
9855                   goto op_semantics_73;
9856                   break;
9857                 case 0x0f:
9858                   goto op_semantics_74;
9859                   break;
9860               }
9861             break;
9862           case 0xff:
9863               GETBYTE ();
9864               switch (op[2] & 0x0f)
9865               {
9866                 case 0x00:
9867                 case 0x01:
9868                 case 0x02:
9869                 case 0x03:
9870                 case 0x04:
9871                 case 0x05:
9872                 case 0x06:
9873                 case 0x07:
9874                 case 0x08:
9875                 case 0x09:
9876                 case 0x0a:
9877                 case 0x0b:
9878                 case 0x0c:
9879                 case 0x0d:
9880                 case 0x0e:
9881                   goto op_semantics_73;
9882                   break;
9883                 case 0x0f:
9884                   goto op_semantics_74;
9885                   break;
9886               }
9887             break;
9888           default: UNSUPPORTED(); break;
9889         }
9890       break;
9891     case 0xfd:
9892         GETBYTE ();
9893         switch (op[1] & 0xff)
9894         {
9895           case 0x00:
9896               GETBYTE ();
9897               switch (op[2] & 0x00)
9898               {
9899                 case 0x00:
9900                   op_semantics_75:
9901                     {
9902                       /** 1111 1101 0000 a000 srca srcb mulhi   %1, %2, %0 */
9903 #line 852 "rx-decode.opc"
9904                       int a AU = (op[1] >> 3) & 0x01;
9905 #line 852 "rx-decode.opc"
9906                       int srca AU = (op[2] >> 4) & 0x0f;
9907 #line 852 "rx-decode.opc"
9908                       int srcb AU = op[2] & 0x0f;
9909                       if (trace)
9910                         {
9911                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9912                                  "/** 1111 1101 0000 a000 srca srcb     mulhi   %1, %2, %0 */",
9913                                  op[0], op[1], op[2]);
9914                           printf ("  a = 0x%x,", a);
9915                           printf ("  srca = 0x%x,", srca);
9916                           printf ("  srcb = 0x%x\n", srcb);
9917                         }
9918                       SYNTAX("mulhi     %1, %2, %0");
9919 #line 852 "rx-decode.opc"
9920                       ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
9921
9922                     }
9923                   break;
9924               }
9925             break;
9926           case 0x01:
9927               GETBYTE ();
9928               switch (op[2] & 0x00)
9929               {
9930                 case 0x00:
9931                   op_semantics_76:
9932                     {
9933                       /** 1111 1101 0000 a001 srca srcb mullo   %1, %2, %0 */
9934 #line 855 "rx-decode.opc"
9935                       int a AU = (op[1] >> 3) & 0x01;
9936 #line 855 "rx-decode.opc"
9937                       int srca AU = (op[2] >> 4) & 0x0f;
9938 #line 855 "rx-decode.opc"
9939                       int srcb AU = op[2] & 0x0f;
9940                       if (trace)
9941                         {
9942                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9943                                  "/** 1111 1101 0000 a001 srca srcb     mullo   %1, %2, %0 */",
9944                                  op[0], op[1], op[2]);
9945                           printf ("  a = 0x%x,", a);
9946                           printf ("  srca = 0x%x,", srca);
9947                           printf ("  srcb = 0x%x\n", srcb);
9948                         }
9949                       SYNTAX("mullo     %1, %2, %0");
9950 #line 855 "rx-decode.opc"
9951                       ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
9952
9953                     }
9954                   break;
9955               }
9956             break;
9957           case 0x02:
9958               GETBYTE ();
9959               switch (op[2] & 0x00)
9960               {
9961                 case 0x00:
9962                   op_semantics_77:
9963                     {
9964                       /** 1111 1101 0000 a010 srca srcb mullh   %1, %2, %0 */
9965 #line 1083 "rx-decode.opc"
9966                       int a AU = (op[1] >> 3) & 0x01;
9967 #line 1083 "rx-decode.opc"
9968                       int srca AU = (op[2] >> 4) & 0x0f;
9969 #line 1083 "rx-decode.opc"
9970                       int srcb AU = op[2] & 0x0f;
9971                       if (trace)
9972                         {
9973                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9974                                  "/** 1111 1101 0000 a010 srca srcb     mullh   %1, %2, %0 */",
9975                                  op[0], op[1], op[2]);
9976                           printf ("  a = 0x%x,", a);
9977                           printf ("  srca = 0x%x,", srca);
9978                           printf ("  srcb = 0x%x\n", srcb);
9979                         }
9980                       SYNTAX("mullh     %1, %2, %0");
9981 #line 1083 "rx-decode.opc"
9982                       ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
9983
9984                     }
9985                   break;
9986               }
9987             break;
9988           case 0x03:
9989               GETBYTE ();
9990               switch (op[2] & 0x00)
9991               {
9992                 case 0x00:
9993                   op_semantics_78:
9994                     {
9995                       /** 1111 1101 0000 a011 srca srcb         emula   %1, %2, %0 */
9996 #line 1068 "rx-decode.opc"
9997                       int a AU = (op[1] >> 3) & 0x01;
9998 #line 1068 "rx-decode.opc"
9999                       int srca AU = (op[2] >> 4) & 0x0f;
10000 #line 1068 "rx-decode.opc"
10001                       int srcb AU = op[2] & 0x0f;
10002                       if (trace)
10003                         {
10004                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10005                                  "/** 1111 1101 0000 a011 srca srcb     emula   %1, %2, %0 */",
10006                                  op[0], op[1], op[2]);
10007                           printf ("  a = 0x%x,", a);
10008                           printf ("  srca = 0x%x,", srca);
10009                           printf ("  srcb = 0x%x\n", srcb);
10010                         }
10011                       SYNTAX("emula     %1, %2, %0");
10012 #line 1068 "rx-decode.opc"
10013                       ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
10014
10015                     }
10016                   break;
10017               }
10018             break;
10019           case 0x04:
10020               GETBYTE ();
10021               switch (op[2] & 0x00)
10022               {
10023                 case 0x00:
10024                   op_semantics_79:
10025                     {
10026                       /** 1111 1101 0000 a100 srca srcb machi   %1, %2, %0 */
10027 #line 858 "rx-decode.opc"
10028                       int a AU = (op[1] >> 3) & 0x01;
10029 #line 858 "rx-decode.opc"
10030                       int srca AU = (op[2] >> 4) & 0x0f;
10031 #line 858 "rx-decode.opc"
10032                       int srcb AU = op[2] & 0x0f;
10033                       if (trace)
10034                         {
10035                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10036                                  "/** 1111 1101 0000 a100 srca srcb     machi   %1, %2, %0 */",
10037                                  op[0], op[1], op[2]);
10038                           printf ("  a = 0x%x,", a);
10039                           printf ("  srca = 0x%x,", srca);
10040                           printf ("  srcb = 0x%x\n", srcb);
10041                         }
10042                       SYNTAX("machi     %1, %2, %0");
10043 #line 858 "rx-decode.opc"
10044                       ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
10045
10046                     }
10047                   break;
10048               }
10049             break;
10050           case 0x05:
10051               GETBYTE ();
10052               switch (op[2] & 0x00)
10053               {
10054                 case 0x00:
10055                   op_semantics_80:
10056                     {
10057                       /** 1111 1101 0000 a101 srca srcb maclo   %1, %2, %0 */
10058 #line 861 "rx-decode.opc"
10059                       int a AU = (op[1] >> 3) & 0x01;
10060 #line 861 "rx-decode.opc"
10061                       int srca AU = (op[2] >> 4) & 0x0f;
10062 #line 861 "rx-decode.opc"
10063                       int srcb AU = op[2] & 0x0f;
10064                       if (trace)
10065                         {
10066                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10067                                  "/** 1111 1101 0000 a101 srca srcb     maclo   %1, %2, %0 */",
10068                                  op[0], op[1], op[2]);
10069                           printf ("  a = 0x%x,", a);
10070                           printf ("  srca = 0x%x,", srca);
10071                           printf ("  srcb = 0x%x\n", srcb);
10072                         }
10073                       SYNTAX("maclo     %1, %2, %0");
10074 #line 861 "rx-decode.opc"
10075                       ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
10076
10077                     }
10078                   break;
10079               }
10080             break;
10081           case 0x06:
10082               GETBYTE ();
10083               switch (op[2] & 0x00)
10084               {
10085                 case 0x00:
10086                   op_semantics_81:
10087                     {
10088                       /** 1111 1101 0000 a110 srca srcb maclh   %1, %2, %0 */
10089 #line 1071 "rx-decode.opc"
10090                       int a AU = (op[1] >> 3) & 0x01;
10091 #line 1071 "rx-decode.opc"
10092                       int srca AU = (op[2] >> 4) & 0x0f;
10093 #line 1071 "rx-decode.opc"
10094                       int srcb AU = op[2] & 0x0f;
10095                       if (trace)
10096                         {
10097                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10098                                  "/** 1111 1101 0000 a110 srca srcb     maclh   %1, %2, %0 */",
10099                                  op[0], op[1], op[2]);
10100                           printf ("  a = 0x%x,", a);
10101                           printf ("  srca = 0x%x,", srca);
10102                           printf ("  srcb = 0x%x\n", srcb);
10103                         }
10104                       SYNTAX("maclh     %1, %2, %0");
10105 #line 1071 "rx-decode.opc"
10106                       ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
10107
10108                     }
10109                   break;
10110               }
10111             break;
10112           case 0x07:
10113               GETBYTE ();
10114               switch (op[2] & 0x00)
10115               {
10116                 case 0x00:
10117                   op_semantics_82:
10118                     {
10119                       /** 1111 1101 0000 a111 srca srcb         emaca   %1, %2, %0 */
10120 #line 1062 "rx-decode.opc"
10121                       int a AU = (op[1] >> 3) & 0x01;
10122 #line 1062 "rx-decode.opc"
10123                       int srca AU = (op[2] >> 4) & 0x0f;
10124 #line 1062 "rx-decode.opc"
10125                       int srcb AU = op[2] & 0x0f;
10126                       if (trace)
10127                         {
10128                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10129                                  "/** 1111 1101 0000 a111 srca srcb     emaca   %1, %2, %0 */",
10130                                  op[0], op[1], op[2]);
10131                           printf ("  a = 0x%x,", a);
10132                           printf ("  srca = 0x%x,", srca);
10133                           printf ("  srcb = 0x%x\n", srcb);
10134                         }
10135                       SYNTAX("emaca     %1, %2, %0");
10136 #line 1062 "rx-decode.opc"
10137                       ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
10138
10139                     }
10140                   break;
10141               }
10142             break;
10143           case 0x08:
10144               GETBYTE ();
10145               switch (op[2] & 0x00)
10146               {
10147                 case 0x00:
10148                   goto op_semantics_75;
10149                   break;
10150               }
10151             break;
10152           case 0x09:
10153               GETBYTE ();
10154               switch (op[2] & 0x00)
10155               {
10156                 case 0x00:
10157                   goto op_semantics_76;
10158                   break;
10159               }
10160             break;
10161           case 0x0a:
10162               GETBYTE ();
10163               switch (op[2] & 0x00)
10164               {
10165                 case 0x00:
10166                   goto op_semantics_77;
10167                   break;
10168               }
10169             break;
10170           case 0x0b:
10171               GETBYTE ();
10172               switch (op[2] & 0x00)
10173               {
10174                 case 0x00:
10175                   goto op_semantics_78;
10176                   break;
10177               }
10178             break;
10179           case 0x0c:
10180               GETBYTE ();
10181               switch (op[2] & 0x00)
10182               {
10183                 case 0x00:
10184                   goto op_semantics_79;
10185                   break;
10186               }
10187             break;
10188           case 0x0d:
10189               GETBYTE ();
10190               switch (op[2] & 0x00)
10191               {
10192                 case 0x00:
10193                   goto op_semantics_80;
10194                   break;
10195               }
10196             break;
10197           case 0x0e:
10198               GETBYTE ();
10199               switch (op[2] & 0x00)
10200               {
10201                 case 0x00:
10202                   goto op_semantics_81;
10203                   break;
10204               }
10205             break;
10206           case 0x0f:
10207               GETBYTE ();
10208               switch (op[2] & 0x00)
10209               {
10210                 case 0x00:
10211                   goto op_semantics_82;
10212                   break;
10213               }
10214             break;
10215           case 0x17:
10216               GETBYTE ();
10217               switch (op[2] & 0x70)
10218               {
10219                 case 0x00:
10220                     {
10221                       /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
10222 #line 864 "rx-decode.opc"
10223                       int a AU = (op[2] >> 7) & 0x01;
10224 #line 864 "rx-decode.opc"
10225                       int rsrc AU = op[2] & 0x0f;
10226                       if (trace)
10227                         {
10228                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10229                                  "/** 1111 1101 0001 0111 a000 rsrc     mvtachi %1, %0 */",
10230                                  op[0], op[1], op[2]);
10231                           printf ("  a = 0x%x,", a);
10232                           printf ("  rsrc = 0x%x\n", rsrc);
10233                         }
10234                       SYNTAX("mvtachi   %1, %0");
10235 #line 864 "rx-decode.opc"
10236                       ID(mvtachi); DR(a+32); SR(rsrc); F_____;
10237
10238                     }
10239                   break;
10240                 case 0x10:
10241                     {
10242                       /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
10243 #line 867 "rx-decode.opc"
10244                       int a AU = (op[2] >> 7) & 0x01;
10245 #line 867 "rx-decode.opc"
10246                       int rsrc AU = op[2] & 0x0f;
10247                       if (trace)
10248                         {
10249                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10250                                  "/** 1111 1101 0001 0111 a001 rsrc     mvtaclo %1, %0 */",
10251                                  op[0], op[1], op[2]);
10252                           printf ("  a = 0x%x,", a);
10253                           printf ("  rsrc = 0x%x\n", rsrc);
10254                         }
10255                       SYNTAX("mvtaclo   %1, %0");
10256 #line 867 "rx-decode.opc"
10257                       ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
10258
10259                     }
10260                   break;
10261                 case 0x30:
10262                     {
10263                       /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */
10264 #line 1089 "rx-decode.opc"
10265                       int a AU = (op[2] >> 7) & 0x01;
10266 #line 1089 "rx-decode.opc"
10267                       int rdst AU = op[2] & 0x0f;
10268                       if (trace)
10269                         {
10270                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10271                                  "/** 1111 1101 0001 0111 a011 rdst     mvtacgu %0, %1 */",
10272                                  op[0], op[1], op[2]);
10273                           printf ("  a = 0x%x,", a);
10274                           printf ("  rdst = 0x%x\n", rdst);
10275                         }
10276                       SYNTAX("mvtacgu   %0, %1");
10277 #line 1089 "rx-decode.opc"
10278                       ID(mvtacgu); DR(a+32); SR(rdst); F_____;
10279
10280                     }
10281                   break;
10282                 default: UNSUPPORTED(); break;
10283               }
10284             break;
10285           case 0x18:
10286               GETBYTE ();
10287               switch (op[2] & 0x6f)
10288               {
10289                 case 0x00:
10290                     {
10291                       /** 1111 1101 0001 1000 a00i 0000 racw    #%1, %0 */
10292 #line 879 "rx-decode.opc"
10293                       int a AU = (op[2] >> 7) & 0x01;
10294 #line 879 "rx-decode.opc"
10295                       int i AU = (op[2] >> 4) & 0x01;
10296                       if (trace)
10297                         {
10298                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10299                                  "/** 1111 1101 0001 1000 a00i 0000     racw    #%1, %0 */",
10300                                  op[0], op[1], op[2]);
10301                           printf ("  a = 0x%x,", a);
10302                           printf ("  i = 0x%x\n", i);
10303                         }
10304                       SYNTAX("racw      #%1, %0");
10305 #line 879 "rx-decode.opc"
10306                       ID(racw); SC(i+1); DR(a+32); F_____;
10307
10308                     /*----------------------------------------------------------------------*/
10309                     /* SAT                                                                      */
10310
10311                     }
10312                   break;
10313                 case 0x40:
10314                     {
10315                       /** 1111 1101 0001 1000 a10i 0000 rdacw   #%1, %0 */
10316 #line 1098 "rx-decode.opc"
10317                       int a AU = (op[2] >> 7) & 0x01;
10318 #line 1098 "rx-decode.opc"
10319                       int i AU = (op[2] >> 4) & 0x01;
10320                       if (trace)
10321                         {
10322                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10323                                  "/** 1111 1101 0001 1000 a10i 0000     rdacw   #%1, %0 */",
10324                                  op[0], op[1], op[2]);
10325                           printf ("  a = 0x%x,", a);
10326                           printf ("  i = 0x%x\n", i);
10327                         }
10328                       SYNTAX("rdacw     #%1, %0");
10329 #line 1098 "rx-decode.opc"
10330                       ID(rdacw); SC(i+1); DR(a+32); F_____;
10331
10332                     }
10333                   break;
10334                 default: UNSUPPORTED(); break;
10335               }
10336             break;
10337           case 0x19:
10338               GETBYTE ();
10339               switch (op[2] & 0x6f)
10340               {
10341                 case 0x00:
10342                     {
10343                       /** 1111 1101 0001 1001 a00i 0000 racl    #%1, %0 */
10344 #line 1092 "rx-decode.opc"
10345                       int a AU = (op[2] >> 7) & 0x01;
10346 #line 1092 "rx-decode.opc"
10347                       int i AU = (op[2] >> 4) & 0x01;
10348                       if (trace)
10349                         {
10350                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10351                                  "/** 1111 1101 0001 1001 a00i 0000     racl    #%1, %0 */",
10352                                  op[0], op[1], op[2]);
10353                           printf ("  a = 0x%x,", a);
10354                           printf ("  i = 0x%x\n", i);
10355                         }
10356                       SYNTAX("racl      #%1, %0");
10357 #line 1092 "rx-decode.opc"
10358                       ID(racl); SC(i+1); DR(a+32); F_____;
10359
10360                     }
10361                   break;
10362                 case 0x40:
10363                     {
10364                       /** 1111 1101 0001 1001 a10i 0000 rdacl   #%1, %0 */
10365 #line 1095 "rx-decode.opc"
10366                       int a AU = (op[2] >> 7) & 0x01;
10367 #line 1095 "rx-decode.opc"
10368                       int i AU = (op[2] >> 4) & 0x01;
10369                       if (trace)
10370                         {
10371                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10372                                  "/** 1111 1101 0001 1001 a10i 0000     rdacl   #%1, %0 */",
10373                                  op[0], op[1], op[2]);
10374                           printf ("  a = 0x%x,", a);
10375                           printf ("  i = 0x%x\n", i);
10376                         }
10377                       SYNTAX("rdacl     #%1, %0");
10378 #line 1095 "rx-decode.opc"
10379                       ID(rdacl); SC(i+1); DR(a+32); F_____;
10380
10381                     }
10382                   break;
10383                 default: UNSUPPORTED(); break;
10384               }
10385             break;
10386           case 0x1e:
10387               GETBYTE ();
10388               switch (op[2] & 0x30)
10389               {
10390                 case 0x00:
10391                   op_semantics_83:
10392                     {
10393                       /** 1111 1101 0001 111i a m00 rdst        mvfachi #%2, %1, %0 */
10394 #line 870 "rx-decode.opc"
10395                       int i AU = op[1] & 0x01;
10396 #line 870 "rx-decode.opc"
10397                       int a AU = (op[2] >> 7) & 0x01;
10398 #line 870 "rx-decode.opc"
10399                       int m AU = (op[2] >> 6) & 0x01;
10400 #line 870 "rx-decode.opc"
10401                       int rdst AU = op[2] & 0x0f;
10402                       if (trace)
10403                         {
10404                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10405                                  "/** 1111 1101 0001 111i a m00 rdst    mvfachi #%2, %1, %0 */",
10406                                  op[0], op[1], op[2]);
10407                           printf ("  i = 0x%x,", i);
10408                           printf ("  a = 0x%x,", a);
10409                           printf ("  m = 0x%x,", m);
10410                           printf ("  rdst = 0x%x\n", rdst);
10411                         }
10412                       SYNTAX("mvfachi   #%2, %1, %0");
10413 #line 870 "rx-decode.opc"
10414                       ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10415
10416                     }
10417                   break;
10418                 case 0x10:
10419                   op_semantics_84:
10420                     {
10421                       /** 1111 1101 0001 111i a m01 rdst        mvfaclo #%2, %1, %0 */
10422 #line 876 "rx-decode.opc"
10423                       int i AU = op[1] & 0x01;
10424 #line 876 "rx-decode.opc"
10425                       int a AU = (op[2] >> 7) & 0x01;
10426 #line 876 "rx-decode.opc"
10427                       int m AU = (op[2] >> 6) & 0x01;
10428 #line 876 "rx-decode.opc"
10429                       int rdst AU = op[2] & 0x0f;
10430                       if (trace)
10431                         {
10432                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10433                                  "/** 1111 1101 0001 111i a m01 rdst    mvfaclo #%2, %1, %0 */",
10434                                  op[0], op[1], op[2]);
10435                           printf ("  i = 0x%x,", i);
10436                           printf ("  a = 0x%x,", a);
10437                           printf ("  m = 0x%x,", m);
10438                           printf ("  rdst = 0x%x\n", rdst);
10439                         }
10440                       SYNTAX("mvfaclo   #%2, %1, %0");
10441 #line 876 "rx-decode.opc"
10442                       ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10443
10444                     }
10445                   break;
10446                 case 0x20:
10447                   op_semantics_85:
10448                     {
10449                       /** 1111 1101 0001 111i a m10 rdst        mvfacmi #%2, %1, %0 */
10450 #line 873 "rx-decode.opc"
10451                       int i AU = op[1] & 0x01;
10452 #line 873 "rx-decode.opc"
10453                       int a AU = (op[2] >> 7) & 0x01;
10454 #line 873 "rx-decode.opc"
10455                       int m AU = (op[2] >> 6) & 0x01;
10456 #line 873 "rx-decode.opc"
10457                       int rdst AU = op[2] & 0x0f;
10458                       if (trace)
10459                         {
10460                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10461                                  "/** 1111 1101 0001 111i a m10 rdst    mvfacmi #%2, %1, %0 */",
10462                                  op[0], op[1], op[2]);
10463                           printf ("  i = 0x%x,", i);
10464                           printf ("  a = 0x%x,", a);
10465                           printf ("  m = 0x%x,", m);
10466                           printf ("  rdst = 0x%x\n", rdst);
10467                         }
10468                       SYNTAX("mvfacmi   #%2, %1, %0");
10469 #line 873 "rx-decode.opc"
10470                       ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10471
10472                     }
10473                   break;
10474                 case 0x30:
10475                   op_semantics_86:
10476                     {
10477                       /** 1111 1101 0001 111i a m11 rdst        mvfacgu #%2, %1, %0 */
10478 #line 1086 "rx-decode.opc"
10479                       int i AU = op[1] & 0x01;
10480 #line 1086 "rx-decode.opc"
10481                       int a AU = (op[2] >> 7) & 0x01;
10482 #line 1086 "rx-decode.opc"
10483                       int m AU = (op[2] >> 6) & 0x01;
10484 #line 1086 "rx-decode.opc"
10485                       int rdst AU = op[2] & 0x0f;
10486                       if (trace)
10487                         {
10488                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10489                                  "/** 1111 1101 0001 111i a m11 rdst    mvfacgu #%2, %1, %0 */",
10490                                  op[0], op[1], op[2]);
10491                           printf ("  i = 0x%x,", i);
10492                           printf ("  a = 0x%x,", a);
10493                           printf ("  m = 0x%x,", m);
10494                           printf ("  rdst = 0x%x\n", rdst);
10495                         }
10496                       SYNTAX("mvfacgu   #%2, %1, %0");
10497 #line 1086 "rx-decode.opc"
10498                       ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10499
10500                     }
10501                   break;
10502               }
10503             break;
10504           case 0x1f:
10505               GETBYTE ();
10506               switch (op[2] & 0x30)
10507               {
10508                 case 0x00:
10509                   goto op_semantics_83;
10510                   break;
10511                 case 0x10:
10512                   goto op_semantics_84;
10513                   break;
10514                 case 0x20:
10515                   goto op_semantics_85;
10516                   break;
10517                 case 0x30:
10518                   goto op_semantics_86;
10519                   break;
10520               }
10521             break;
10522           case 0x20:
10523               GETBYTE ();
10524               switch (op[2] & 0x00)
10525               {
10526                 case 0x00:
10527                   op_semantics_87:
10528                     {
10529                       /** 1111 1101 0010 0p sz rdst rsrc        mov%s   %1, %0 */
10530 #line 348 "rx-decode.opc"
10531                       int p AU = (op[1] >> 2) & 0x01;
10532 #line 348 "rx-decode.opc"
10533                       int sz AU = op[1] & 0x03;
10534 #line 348 "rx-decode.opc"
10535                       int rdst AU = (op[2] >> 4) & 0x0f;
10536 #line 348 "rx-decode.opc"
10537                       int rsrc AU = op[2] & 0x0f;
10538                       if (trace)
10539                         {
10540                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10541                                  "/** 1111 1101 0010 0p sz rdst rsrc    mov%s   %1, %0 */",
10542                                  op[0], op[1], op[2]);
10543                           printf ("  p = 0x%x,", p);
10544                           printf ("  sz = 0x%x,", sz);
10545                           printf ("  rdst = 0x%x,", rdst);
10546                           printf ("  rsrc = 0x%x\n", rsrc);
10547                         }
10548                       SYNTAX("mov%s     %1, %0");
10549 #line 348 "rx-decode.opc"
10550                       ID(mov); sBWL (sz); SR(rsrc); F_____;
10551                       OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
10552
10553                     }
10554                   break;
10555               }
10556             break;
10557           case 0x21:
10558               GETBYTE ();
10559               switch (op[2] & 0x00)
10560               {
10561                 case 0x00:
10562                   goto op_semantics_87;
10563                   break;
10564               }
10565             break;
10566           case 0x22:
10567               GETBYTE ();
10568               switch (op[2] & 0x00)
10569               {
10570                 case 0x00:
10571                   goto op_semantics_87;
10572                   break;
10573               }
10574             break;
10575           case 0x24:
10576               GETBYTE ();
10577               switch (op[2] & 0x00)
10578               {
10579                 case 0x00:
10580                   goto op_semantics_87;
10581                   break;
10582               }
10583             break;
10584           case 0x25:
10585               GETBYTE ();
10586               switch (op[2] & 0x00)
10587               {
10588                 case 0x00:
10589                   goto op_semantics_87;
10590                   break;
10591               }
10592             break;
10593           case 0x26:
10594               GETBYTE ();
10595               switch (op[2] & 0x00)
10596               {
10597                 case 0x00:
10598                   goto op_semantics_87;
10599                   break;
10600               }
10601             break;
10602           case 0x27:
10603               GETBYTE ();
10604               switch (op[2] & 0x00)
10605               {
10606                 case 0x00:
10607                     {
10608                       /** 1111 1101 0010 0111 rdst rsrc movco   %1, [%0] */
10609 #line 1050 "rx-decode.opc"
10610                       int rdst AU = (op[2] >> 4) & 0x0f;
10611 #line 1050 "rx-decode.opc"
10612                       int rsrc AU = op[2] & 0x0f;
10613                       if (trace)
10614                         {
10615                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10616                                  "/** 1111 1101 0010 0111 rdst rsrc     movco   %1, [%0] */",
10617                                  op[0], op[1], op[2]);
10618                           printf ("  rdst = 0x%x,", rdst);
10619                           printf ("  rsrc = 0x%x\n", rsrc);
10620                         }
10621                       SYNTAX("movco     %1, [%0]");
10622 #line 1050 "rx-decode.opc"
10623                        ID(movco); SR(rsrc); DR(rdst); F_____;
10624
10625                     }
10626                   break;
10627               }
10628             break;
10629           case 0x28:
10630               GETBYTE ();
10631               switch (op[2] & 0x00)
10632               {
10633                 case 0x00:
10634                   op_semantics_88:
10635                     {
10636                       /** 1111 1101 0010 1p sz rsrc rdst        mov%s   %1, %0 */
10637 #line 352 "rx-decode.opc"
10638                       int p AU = (op[1] >> 2) & 0x01;
10639 #line 352 "rx-decode.opc"
10640                       int sz AU = op[1] & 0x03;
10641 #line 352 "rx-decode.opc"
10642                       int rsrc AU = (op[2] >> 4) & 0x0f;
10643 #line 352 "rx-decode.opc"
10644                       int rdst AU = op[2] & 0x0f;
10645                       if (trace)
10646                         {
10647                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10648                                  "/** 1111 1101 0010 1p sz rsrc rdst    mov%s   %1, %0 */",
10649                                  op[0], op[1], op[2]);
10650                           printf ("  p = 0x%x,", p);
10651                           printf ("  sz = 0x%x,", sz);
10652                           printf ("  rsrc = 0x%x,", rsrc);
10653                           printf ("  rdst = 0x%x\n", rdst);
10654                         }
10655                       SYNTAX("mov%s     %1, %0");
10656 #line 352 "rx-decode.opc"
10657                       ID(mov); sBWL (sz); DR(rdst); F_____;
10658                       OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10659
10660                     }
10661                   break;
10662               }
10663             break;
10664           case 0x29:
10665               GETBYTE ();
10666               switch (op[2] & 0x00)
10667               {
10668                 case 0x00:
10669                   goto op_semantics_88;
10670                   break;
10671               }
10672             break;
10673           case 0x2a:
10674               GETBYTE ();
10675               switch (op[2] & 0x00)
10676               {
10677                 case 0x00:
10678                   goto op_semantics_88;
10679                   break;
10680               }
10681             break;
10682           case 0x2c:
10683               GETBYTE ();
10684               switch (op[2] & 0x00)
10685               {
10686                 case 0x00:
10687                   goto op_semantics_88;
10688                   break;
10689               }
10690             break;
10691           case 0x2d:
10692               GETBYTE ();
10693               switch (op[2] & 0x00)
10694               {
10695                 case 0x00:
10696                   goto op_semantics_88;
10697                   break;
10698               }
10699             break;
10700           case 0x2e:
10701               GETBYTE ();
10702               switch (op[2] & 0x00)
10703               {
10704                 case 0x00:
10705                   goto op_semantics_88;
10706                   break;
10707               }
10708             break;
10709           case 0x2f:
10710               GETBYTE ();
10711               switch (op[2] & 0x00)
10712               {
10713                 case 0x00:
10714                     {
10715                       /** 1111 1101 0010 1111 rsrc rdst movli   [%1], %0 */
10716 #line 1053 "rx-decode.opc"
10717                       int rsrc AU = (op[2] >> 4) & 0x0f;
10718 #line 1053 "rx-decode.opc"
10719                       int rdst AU = op[2] & 0x0f;
10720                       if (trace)
10721                         {
10722                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10723                                  "/** 1111 1101 0010 1111 rsrc rdst     movli   [%1], %0 */",
10724                                  op[0], op[1], op[2]);
10725                           printf ("  rsrc = 0x%x,", rsrc);
10726                           printf ("  rdst = 0x%x\n", rdst);
10727                         }
10728                       SYNTAX("movli     [%1], %0");
10729 #line 1053 "rx-decode.opc"
10730                        ID(movli); SR(rsrc); DR(rdst); F_____;
10731
10732                     }
10733                   break;
10734               }
10735             break;
10736           case 0x38:
10737               GETBYTE ();
10738               switch (op[2] & 0x00)
10739               {
10740                 case 0x00:
10741                   op_semantics_89:
10742                     {
10743                       /** 1111 1101 0011 1p sz rsrc rdst        movu%s  %1, %0 */
10744 #line 362 "rx-decode.opc"
10745                       int p AU = (op[1] >> 2) & 0x01;
10746 #line 362 "rx-decode.opc"
10747                       int sz AU = op[1] & 0x03;
10748 #line 362 "rx-decode.opc"
10749                       int rsrc AU = (op[2] >> 4) & 0x0f;
10750 #line 362 "rx-decode.opc"
10751                       int rdst AU = op[2] & 0x0f;
10752                       if (trace)
10753                         {
10754                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10755                                  "/** 1111 1101 0011 1p sz rsrc rdst    movu%s  %1, %0 */",
10756                                  op[0], op[1], op[2]);
10757                           printf ("  p = 0x%x,", p);
10758                           printf ("  sz = 0x%x,", sz);
10759                           printf ("  rsrc = 0x%x,", rsrc);
10760                           printf ("  rdst = 0x%x\n", rdst);
10761                         }
10762                       SYNTAX("movu%s    %1, %0");
10763 #line 362 "rx-decode.opc"
10764                       ID(mov); uBW (sz); DR(rdst); F_____;
10765                        OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10766
10767                     /*----------------------------------------------------------------------*/
10768                     /* PUSH/POP                                                         */
10769
10770                     }
10771                   break;
10772               }
10773             break;
10774           case 0x39:
10775               GETBYTE ();
10776               switch (op[2] & 0x00)
10777               {
10778                 case 0x00:
10779                   goto op_semantics_89;
10780                   break;
10781               }
10782             break;
10783           case 0x3a:
10784               GETBYTE ();
10785               switch (op[2] & 0x00)
10786               {
10787                 case 0x00:
10788                   goto op_semantics_89;
10789                   break;
10790               }
10791             break;
10792           case 0x3c:
10793               GETBYTE ();
10794               switch (op[2] & 0x00)
10795               {
10796                 case 0x00:
10797                   goto op_semantics_89;
10798                   break;
10799               }
10800             break;
10801           case 0x3d:
10802               GETBYTE ();
10803               switch (op[2] & 0x00)
10804               {
10805                 case 0x00:
10806                   goto op_semantics_89;
10807                   break;
10808               }
10809             break;
10810           case 0x3e:
10811               GETBYTE ();
10812               switch (op[2] & 0x00)
10813               {
10814                 case 0x00:
10815                   goto op_semantics_89;
10816                   break;
10817               }
10818             break;
10819           case 0x44:
10820               GETBYTE ();
10821               switch (op[2] & 0x00)
10822               {
10823                 case 0x00:
10824                   op_semantics_90:
10825                     {
10826                       /** 1111 1101 0100 a100 srca srcb msbhi   %1, %2, %0 */
10827 #line 1074 "rx-decode.opc"
10828                       int a AU = (op[1] >> 3) & 0x01;
10829 #line 1074 "rx-decode.opc"
10830                       int srca AU = (op[2] >> 4) & 0x0f;
10831 #line 1074 "rx-decode.opc"
10832                       int srcb AU = op[2] & 0x0f;
10833                       if (trace)
10834                         {
10835                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10836                                  "/** 1111 1101 0100 a100 srca srcb     msbhi   %1, %2, %0 */",
10837                                  op[0], op[1], op[2]);
10838                           printf ("  a = 0x%x,", a);
10839                           printf ("  srca = 0x%x,", srca);
10840                           printf ("  srcb = 0x%x\n", srcb);
10841                         }
10842                       SYNTAX("msbhi     %1, %2, %0");
10843 #line 1074 "rx-decode.opc"
10844                       ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
10845
10846                     }
10847                   break;
10848               }
10849             break;
10850           case 0x45:
10851               GETBYTE ();
10852               switch (op[2] & 0x00)
10853               {
10854                 case 0x00:
10855                   op_semantics_91:
10856                     {
10857                       /** 1111 1101 0100 a101 srca srcb msblo   %1, %2, %0 */
10858 #line 1080 "rx-decode.opc"
10859                       int a AU = (op[1] >> 3) & 0x01;
10860 #line 1080 "rx-decode.opc"
10861                       int srca AU = (op[2] >> 4) & 0x0f;
10862 #line 1080 "rx-decode.opc"
10863                       int srcb AU = op[2] & 0x0f;
10864                       if (trace)
10865                         {
10866                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10867                                  "/** 1111 1101 0100 a101 srca srcb     msblo   %1, %2, %0 */",
10868                                  op[0], op[1], op[2]);
10869                           printf ("  a = 0x%x,", a);
10870                           printf ("  srca = 0x%x,", srca);
10871                           printf ("  srcb = 0x%x\n", srcb);
10872                         }
10873                       SYNTAX("msblo     %1, %2, %0");
10874 #line 1080 "rx-decode.opc"
10875                       ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
10876
10877                     }
10878                   break;
10879               }
10880             break;
10881           case 0x46:
10882               GETBYTE ();
10883               switch (op[2] & 0x00)
10884               {
10885                 case 0x00:
10886                   op_semantics_92:
10887                     {
10888                       /** 1111 1101 0100 a110 srca srcb msblh   %1, %2, %0 */
10889 #line 1077 "rx-decode.opc"
10890                       int a AU = (op[1] >> 3) & 0x01;
10891 #line 1077 "rx-decode.opc"
10892                       int srca AU = (op[2] >> 4) & 0x0f;
10893 #line 1077 "rx-decode.opc"
10894                       int srcb AU = op[2] & 0x0f;
10895                       if (trace)
10896                         {
10897                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10898                                  "/** 1111 1101 0100 a110 srca srcb     msblh   %1, %2, %0 */",
10899                                  op[0], op[1], op[2]);
10900                           printf ("  a = 0x%x,", a);
10901                           printf ("  srca = 0x%x,", srca);
10902                           printf ("  srcb = 0x%x\n", srcb);
10903                         }
10904                       SYNTAX("msblh     %1, %2, %0");
10905 #line 1077 "rx-decode.opc"
10906                       ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
10907
10908                     }
10909                   break;
10910               }
10911             break;
10912           case 0x47:
10913               GETBYTE ();
10914               switch (op[2] & 0x00)
10915               {
10916                 case 0x00:
10917                   op_semantics_93:
10918                     {
10919                       /** 1111 1101 0100 a111 srca srcb         emsba   %1, %2, %0 */
10920 #line 1065 "rx-decode.opc"
10921                       int a AU = (op[1] >> 3) & 0x01;
10922 #line 1065 "rx-decode.opc"
10923                       int srca AU = (op[2] >> 4) & 0x0f;
10924 #line 1065 "rx-decode.opc"
10925                       int srcb AU = op[2] & 0x0f;
10926                       if (trace)
10927                         {
10928                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10929                                  "/** 1111 1101 0100 a111 srca srcb     emsba   %1, %2, %0 */",
10930                                  op[0], op[1], op[2]);
10931                           printf ("  a = 0x%x,", a);
10932                           printf ("  srca = 0x%x,", srca);
10933                           printf ("  srcb = 0x%x\n", srcb);
10934                         }
10935                       SYNTAX("emsba     %1, %2, %0");
10936 #line 1065 "rx-decode.opc"
10937                       ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
10938
10939                     }
10940                   break;
10941               }
10942             break;
10943           case 0x4c:
10944               GETBYTE ();
10945               switch (op[2] & 0x00)
10946               {
10947                 case 0x00:
10948                   goto op_semantics_90;
10949                   break;
10950               }
10951             break;
10952           case 0x4d:
10953               GETBYTE ();
10954               switch (op[2] & 0x00)
10955               {
10956                 case 0x00:
10957                   goto op_semantics_91;
10958                   break;
10959               }
10960             break;
10961           case 0x4e:
10962               GETBYTE ();
10963               switch (op[2] & 0x00)
10964               {
10965                 case 0x00:
10966                   goto op_semantics_92;
10967                   break;
10968               }
10969             break;
10970           case 0x4f:
10971               GETBYTE ();
10972               switch (op[2] & 0x00)
10973               {
10974                 case 0x00:
10975                   goto op_semantics_93;
10976                   break;
10977               }
10978             break;
10979           case 0x60:
10980               GETBYTE ();
10981               switch (op[2] & 0x00)
10982               {
10983                 case 0x00:
10984                     {
10985                       /** 1111 1101 0110 0000 rsrc rdst shlr    %2, %0 */
10986 #line 733 "rx-decode.opc"
10987                       int rsrc AU = (op[2] >> 4) & 0x0f;
10988 #line 733 "rx-decode.opc"
10989                       int rdst AU = op[2] & 0x0f;
10990                       if (trace)
10991                         {
10992                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10993                                  "/** 1111 1101 0110 0000 rsrc rdst     shlr    %2, %0 */",
10994                                  op[0], op[1], op[2]);
10995                           printf ("  rsrc = 0x%x,", rsrc);
10996                           printf ("  rdst = 0x%x\n", rdst);
10997                         }
10998                       SYNTAX("shlr      %2, %0");
10999 #line 733 "rx-decode.opc"
11000                       ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
11001
11002                     }
11003                   break;
11004               }
11005             break;
11006           case 0x61:
11007               GETBYTE ();
11008               switch (op[2] & 0x00)
11009               {
11010                 case 0x00:
11011                     {
11012                       /** 1111 1101 0110 0001 rsrc rdst shar    %2, %0 */
11013 #line 723 "rx-decode.opc"
11014                       int rsrc AU = (op[2] >> 4) & 0x0f;
11015 #line 723 "rx-decode.opc"
11016                       int rdst AU = op[2] & 0x0f;
11017                       if (trace)
11018                         {
11019                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11020                                  "/** 1111 1101 0110 0001 rsrc rdst     shar    %2, %0 */",
11021                                  op[0], op[1], op[2]);
11022                           printf ("  rsrc = 0x%x,", rsrc);
11023                           printf ("  rdst = 0x%x\n", rdst);
11024                         }
11025                       SYNTAX("shar      %2, %0");
11026 #line 723 "rx-decode.opc"
11027                       ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
11028
11029                     }
11030                   break;
11031               }
11032             break;
11033           case 0x62:
11034               GETBYTE ();
11035               switch (op[2] & 0x00)
11036               {
11037                 case 0x00:
11038                     {
11039                       /** 1111 1101 0110 0010 rsrc rdst shll    %2, %0 */
11040 #line 713 "rx-decode.opc"
11041                       int rsrc AU = (op[2] >> 4) & 0x0f;
11042 #line 713 "rx-decode.opc"
11043                       int rdst AU = op[2] & 0x0f;
11044                       if (trace)
11045                         {
11046                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11047                                  "/** 1111 1101 0110 0010 rsrc rdst     shll    %2, %0 */",
11048                                  op[0], op[1], op[2]);
11049                           printf ("  rsrc = 0x%x,", rsrc);
11050                           printf ("  rdst = 0x%x\n", rdst);
11051                         }
11052                       SYNTAX("shll      %2, %0");
11053 #line 713 "rx-decode.opc"
11054                       ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
11055
11056                     }
11057                   break;
11058               }
11059             break;
11060           case 0x64:
11061               GETBYTE ();
11062               switch (op[2] & 0x00)
11063               {
11064                 case 0x00:
11065                     {
11066                       /** 1111 1101 0110 0100 rsrc rdst rotr    %1, %0 */
11067 #line 757 "rx-decode.opc"
11068                       int rsrc AU = (op[2] >> 4) & 0x0f;
11069 #line 757 "rx-decode.opc"
11070                       int rdst AU = op[2] & 0x0f;
11071                       if (trace)
11072                         {
11073                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11074                                  "/** 1111 1101 0110 0100 rsrc rdst     rotr    %1, %0 */",
11075                                  op[0], op[1], op[2]);
11076                           printf ("  rsrc = 0x%x,", rsrc);
11077                           printf ("  rdst = 0x%x\n", rdst);
11078                         }
11079                       SYNTAX("rotr      %1, %0");
11080 #line 757 "rx-decode.opc"
11081                       ID(rotr); SR(rsrc); DR(rdst); F__SZC;
11082
11083                     }
11084                   break;
11085               }
11086             break;
11087           case 0x65:
11088               GETBYTE ();
11089               switch (op[2] & 0x00)
11090               {
11091                 case 0x00:
11092                     {
11093                       /** 1111 1101 0110 0101 rsrc rdst revw    %1, %0 */
11094 #line 760 "rx-decode.opc"
11095                       int rsrc AU = (op[2] >> 4) & 0x0f;
11096 #line 760 "rx-decode.opc"
11097                       int rdst AU = op[2] & 0x0f;
11098                       if (trace)
11099                         {
11100                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11101                                  "/** 1111 1101 0110 0101 rsrc rdst     revw    %1, %0 */",
11102                                  op[0], op[1], op[2]);
11103                           printf ("  rsrc = 0x%x,", rsrc);
11104                           printf ("  rdst = 0x%x\n", rdst);
11105                         }
11106                       SYNTAX("revw      %1, %0");
11107 #line 760 "rx-decode.opc"
11108                       ID(revw); SR(rsrc); DR(rdst);
11109
11110                     }
11111                   break;
11112               }
11113             break;
11114           case 0x66:
11115               GETBYTE ();
11116               switch (op[2] & 0x00)
11117               {
11118                 case 0x00:
11119                     {
11120                       /** 1111 1101 0110 0110 rsrc rdst rotl    %1, %0 */
11121 #line 751 "rx-decode.opc"
11122                       int rsrc AU = (op[2] >> 4) & 0x0f;
11123 #line 751 "rx-decode.opc"
11124                       int rdst AU = op[2] & 0x0f;
11125                       if (trace)
11126                         {
11127                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11128                                  "/** 1111 1101 0110 0110 rsrc rdst     rotl    %1, %0 */",
11129                                  op[0], op[1], op[2]);
11130                           printf ("  rsrc = 0x%x,", rsrc);
11131                           printf ("  rdst = 0x%x\n", rdst);
11132                         }
11133                       SYNTAX("rotl      %1, %0");
11134 #line 751 "rx-decode.opc"
11135                       ID(rotl); SR(rsrc); DR(rdst); F__SZC;
11136
11137                     }
11138                   break;
11139               }
11140             break;
11141           case 0x67:
11142               GETBYTE ();
11143               switch (op[2] & 0x00)
11144               {
11145                 case 0x00:
11146                     {
11147                       /** 1111 1101 0110 0111 rsrc rdst revl    %1, %0 */
11148 #line 763 "rx-decode.opc"
11149                       int rsrc AU = (op[2] >> 4) & 0x0f;
11150 #line 763 "rx-decode.opc"
11151                       int rdst AU = op[2] & 0x0f;
11152                       if (trace)
11153                         {
11154                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11155                                  "/** 1111 1101 0110 0111 rsrc rdst     revl    %1, %0 */",
11156                                  op[0], op[1], op[2]);
11157                           printf ("  rsrc = 0x%x,", rsrc);
11158                           printf ("  rdst = 0x%x\n", rdst);
11159                         }
11160                       SYNTAX("revl      %1, %0");
11161 #line 763 "rx-decode.opc"
11162                       ID(revl); SR(rsrc); DR(rdst);
11163
11164                     /*----------------------------------------------------------------------*/
11165                     /* BRANCH                                                           */
11166
11167                     }
11168                   break;
11169               }
11170             break;
11171           case 0x68:
11172               GETBYTE ();
11173               switch (op[2] & 0x00)
11174               {
11175                 case 0x00:
11176                   op_semantics_94:
11177                     {
11178                       /** 1111 1101 0110 100c rsrc rdst mvtc    %1, %0 */
11179 #line 1014 "rx-decode.opc"
11180                       int c AU = op[1] & 0x01;
11181 #line 1014 "rx-decode.opc"
11182                       int rsrc AU = (op[2] >> 4) & 0x0f;
11183 #line 1014 "rx-decode.opc"
11184                       int rdst AU = op[2] & 0x0f;
11185                       if (trace)
11186                         {
11187                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11188                                  "/** 1111 1101 0110 100c rsrc rdst     mvtc    %1, %0 */",
11189                                  op[0], op[1], op[2]);
11190                           printf ("  c = 0x%x,", c);
11191                           printf ("  rsrc = 0x%x,", rsrc);
11192                           printf ("  rdst = 0x%x\n", rdst);
11193                         }
11194                       SYNTAX("mvtc      %1, %0");
11195 #line 1014 "rx-decode.opc"
11196                       ID(mov); SR(rsrc); DR(c*16+rdst + 16);
11197
11198                     }
11199                   break;
11200               }
11201             break;
11202           case 0x69:
11203               GETBYTE ();
11204               switch (op[2] & 0x00)
11205               {
11206                 case 0x00:
11207                   goto op_semantics_94;
11208                   break;
11209               }
11210             break;
11211           case 0x6a:
11212               GETBYTE ();
11213               switch (op[2] & 0x00)
11214               {
11215                 case 0x00:
11216                   op_semantics_95:
11217                     {
11218                       /** 1111 1101 0110 101s rsrc rdst mvfc    %1, %0 */
11219 #line 1017 "rx-decode.opc"
11220                       int s AU = op[1] & 0x01;
11221 #line 1017 "rx-decode.opc"
11222                       int rsrc AU = (op[2] >> 4) & 0x0f;
11223 #line 1017 "rx-decode.opc"
11224                       int rdst AU = op[2] & 0x0f;
11225                       if (trace)
11226                         {
11227                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11228                                  "/** 1111 1101 0110 101s rsrc rdst     mvfc    %1, %0 */",
11229                                  op[0], op[1], op[2]);
11230                           printf ("  s = 0x%x,", s);
11231                           printf ("  rsrc = 0x%x,", rsrc);
11232                           printf ("  rdst = 0x%x\n", rdst);
11233                         }
11234                       SYNTAX("mvfc      %1, %0");
11235 #line 1017 "rx-decode.opc"
11236                       ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
11237
11238                     /*----------------------------------------------------------------------*/
11239                     /* INTERRUPTS                                                               */
11240
11241                     }
11242                   break;
11243               }
11244             break;
11245           case 0x6b:
11246               GETBYTE ();
11247               switch (op[2] & 0x00)
11248               {
11249                 case 0x00:
11250                   goto op_semantics_95;
11251                   break;
11252               }
11253             break;
11254           case 0x6c:
11255               GETBYTE ();
11256               switch (op[2] & 0x00)
11257               {
11258                 case 0x00:
11259                   op_semantics_96:
11260                     {
11261                       /** 1111 1101 0110 110i mmmm rdst rotr    #%1, %0 */
11262 #line 754 "rx-decode.opc"
11263                       int i AU = op[1] & 0x01;
11264 #line 754 "rx-decode.opc"
11265                       int mmmm AU = (op[2] >> 4) & 0x0f;
11266 #line 754 "rx-decode.opc"
11267                       int rdst AU = op[2] & 0x0f;
11268                       if (trace)
11269                         {
11270                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11271                                  "/** 1111 1101 0110 110i mmmm rdst     rotr    #%1, %0 */",
11272                                  op[0], op[1], op[2]);
11273                           printf ("  i = 0x%x,", i);
11274                           printf ("  mmmm = 0x%x,", mmmm);
11275                           printf ("  rdst = 0x%x\n", rdst);
11276                         }
11277                       SYNTAX("rotr      #%1, %0");
11278 #line 754 "rx-decode.opc"
11279                       ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
11280
11281                     }
11282                   break;
11283               }
11284             break;
11285           case 0x6d:
11286               GETBYTE ();
11287               switch (op[2] & 0x00)
11288               {
11289                 case 0x00:
11290                   goto op_semantics_96;
11291                   break;
11292               }
11293             break;
11294           case 0x6e:
11295               GETBYTE ();
11296               switch (op[2] & 0x00)
11297               {
11298                 case 0x00:
11299                   op_semantics_97:
11300                     {
11301                       /** 1111 1101 0110 111i mmmm rdst rotl    #%1, %0 */
11302 #line 748 "rx-decode.opc"
11303                       int i AU = op[1] & 0x01;
11304 #line 748 "rx-decode.opc"
11305                       int mmmm AU = (op[2] >> 4) & 0x0f;
11306 #line 748 "rx-decode.opc"
11307                       int rdst AU = op[2] & 0x0f;
11308                       if (trace)
11309                         {
11310                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11311                                  "/** 1111 1101 0110 111i mmmm rdst     rotl    #%1, %0 */",
11312                                  op[0], op[1], op[2]);
11313                           printf ("  i = 0x%x,", i);
11314                           printf ("  mmmm = 0x%x,", mmmm);
11315                           printf ("  rdst = 0x%x\n", rdst);
11316                         }
11317                       SYNTAX("rotl      #%1, %0");
11318 #line 748 "rx-decode.opc"
11319                       ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
11320
11321                     }
11322                   break;
11323               }
11324             break;
11325           case 0x6f:
11326               GETBYTE ();
11327               switch (op[2] & 0x00)
11328               {
11329                 case 0x00:
11330                   goto op_semantics_97;
11331                   break;
11332               }
11333             break;
11334           case 0x70:
11335               GETBYTE ();
11336               switch (op[2] & 0xf0)
11337               {
11338                 case 0x20:
11339                   op_semantics_98:
11340                     {
11341                       /** 1111 1101 0111 im00 0010rdst  adc     #%1, %0 */
11342 #line 492 "rx-decode.opc"
11343                       int im AU = (op[1] >> 2) & 0x03;
11344 #line 492 "rx-decode.opc"
11345                       int rdst AU = op[2] & 0x0f;
11346                       if (trace)
11347                         {
11348                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11349                                  "/** 1111 1101 0111 im00 0010rdst      adc     #%1, %0 */",
11350                                  op[0], op[1], op[2]);
11351                           printf ("  im = 0x%x,", im);
11352                           printf ("  rdst = 0x%x\n", rdst);
11353                         }
11354                       SYNTAX("adc       #%1, %0");
11355 #line 492 "rx-decode.opc"
11356                       ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
11357
11358                     }
11359                   break;
11360                 case 0x40:
11361                   op_semantics_99:
11362                     {
11363                       /** 1111 1101 0111 im00 0100rdst  max     #%1, %0 */
11364 #line 574 "rx-decode.opc"
11365                       int im AU = (op[1] >> 2) & 0x03;
11366 #line 574 "rx-decode.opc"
11367                       int rdst AU = op[2] & 0x0f;
11368                       if (trace)
11369                         {
11370                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11371                                  "/** 1111 1101 0111 im00 0100rdst      max     #%1, %0 */",
11372                                  op[0], op[1], op[2]);
11373                           printf ("  im = 0x%x,", im);
11374                           printf ("  rdst = 0x%x\n", rdst);
11375                         }
11376                       SYNTAX("max       #%1, %0");
11377 #line 574 "rx-decode.opc"
11378                       int val = IMMex (im);
11379                       if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
11380                         {
11381                           ID (nop7);
11382                           SYNTAX("nop\t; max\t#0x80000000, r0");
11383                         }
11384                       else
11385                         {
11386                           ID(max);
11387                         }
11388                       DR(rdst); SC(val);
11389
11390                     }
11391                   break;
11392                 case 0x50:
11393                   op_semantics_100:
11394                     {
11395                       /** 1111 1101 0111 im00 0101rdst  min     #%1, %0 */
11396 #line 604 "rx-decode.opc"
11397                       int im AU = (op[1] >> 2) & 0x03;
11398 #line 604 "rx-decode.opc"
11399                       int rdst AU = op[2] & 0x0f;
11400                       if (trace)
11401                         {
11402                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11403                                  "/** 1111 1101 0111 im00 0101rdst      min     #%1, %0 */",
11404                                  op[0], op[1], op[2]);
11405                           printf ("  im = 0x%x,", im);
11406                           printf ("  rdst = 0x%x\n", rdst);
11407                         }
11408                       SYNTAX("min       #%1, %0");
11409 #line 604 "rx-decode.opc"
11410                       ID(min); DR(rdst); SC(IMMex(im));
11411
11412                     }
11413                   break;
11414                 case 0x60:
11415                   op_semantics_101:
11416                     {
11417                       /** 1111 1101 0111 im00 0110rdst  emul    #%1, %0 */
11418 #line 662 "rx-decode.opc"
11419                       int im AU = (op[1] >> 2) & 0x03;
11420 #line 662 "rx-decode.opc"
11421                       int rdst AU = op[2] & 0x0f;
11422                       if (trace)
11423                         {
11424                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11425                                  "/** 1111 1101 0111 im00 0110rdst      emul    #%1, %0 */",
11426                                  op[0], op[1], op[2]);
11427                           printf ("  im = 0x%x,", im);
11428                           printf ("  rdst = 0x%x\n", rdst);
11429                         }
11430                       SYNTAX("emul      #%1, %0");
11431 #line 662 "rx-decode.opc"
11432                       ID(emul); DR(rdst); SC(IMMex(im));
11433
11434                     }
11435                   break;
11436                 case 0x70:
11437                   op_semantics_102:
11438                     {
11439                       /** 1111 1101 0111 im00 0111rdst  emulu   #%1, %0 */
11440 #line 674 "rx-decode.opc"
11441                       int im AU = (op[1] >> 2) & 0x03;
11442 #line 674 "rx-decode.opc"
11443                       int rdst AU = op[2] & 0x0f;
11444                       if (trace)
11445                         {
11446                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11447                                  "/** 1111 1101 0111 im00 0111rdst      emulu   #%1, %0 */",
11448                                  op[0], op[1], op[2]);
11449                           printf ("  im = 0x%x,", im);
11450                           printf ("  rdst = 0x%x\n", rdst);
11451                         }
11452                       SYNTAX("emulu     #%1, %0");
11453 #line 674 "rx-decode.opc"
11454                       ID(emulu); DR(rdst); SC(IMMex(im));
11455
11456                     }
11457                   break;
11458                 case 0x80:
11459                   op_semantics_103:
11460                     {
11461                       /** 1111 1101 0111 im00 1000rdst  div     #%1, %0 */
11462 #line 686 "rx-decode.opc"
11463                       int im AU = (op[1] >> 2) & 0x03;
11464 #line 686 "rx-decode.opc"
11465                       int rdst AU = op[2] & 0x0f;
11466                       if (trace)
11467                         {
11468                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11469                                  "/** 1111 1101 0111 im00 1000rdst      div     #%1, %0 */",
11470                                  op[0], op[1], op[2]);
11471                           printf ("  im = 0x%x,", im);
11472                           printf ("  rdst = 0x%x\n", rdst);
11473                         }
11474                       SYNTAX("div       #%1, %0");
11475 #line 686 "rx-decode.opc"
11476                       ID(div); DR(rdst); SC(IMMex(im)); F_O___;
11477
11478                     }
11479                   break;
11480                 case 0x90:
11481                   op_semantics_104:
11482                     {
11483                       /** 1111 1101 0111 im00 1001rdst  divu    #%1, %0 */
11484 #line 698 "rx-decode.opc"
11485                       int im AU = (op[1] >> 2) & 0x03;
11486 #line 698 "rx-decode.opc"
11487                       int rdst AU = op[2] & 0x0f;
11488                       if (trace)
11489                         {
11490                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11491                                  "/** 1111 1101 0111 im00 1001rdst      divu    #%1, %0 */",
11492                                  op[0], op[1], op[2]);
11493                           printf ("  im = 0x%x,", im);
11494                           printf ("  rdst = 0x%x\n", rdst);
11495                         }
11496                       SYNTAX("divu      #%1, %0");
11497 #line 698 "rx-decode.opc"
11498                       ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
11499
11500                     }
11501                   break;
11502                 case 0xc0:
11503                   op_semantics_105:
11504                     {
11505                       /** 1111 1101 0111 im00 1100rdst  tst     #%1, %2 */
11506 #line 471 "rx-decode.opc"
11507                       int im AU = (op[1] >> 2) & 0x03;
11508 #line 471 "rx-decode.opc"
11509                       int rdst AU = op[2] & 0x0f;
11510                       if (trace)
11511                         {
11512                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11513                                  "/** 1111 1101 0111 im00 1100rdst      tst     #%1, %2 */",
11514                                  op[0], op[1], op[2]);
11515                           printf ("  im = 0x%x,", im);
11516                           printf ("  rdst = 0x%x\n", rdst);
11517                         }
11518                       SYNTAX("tst       #%1, %2");
11519 #line 471 "rx-decode.opc"
11520                       ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
11521
11522                     }
11523                   break;
11524                 case 0xd0:
11525                   op_semantics_106:
11526                     {
11527                       /** 1111 1101 0111 im00 1101rdst  xor     #%1, %0 */
11528 #line 450 "rx-decode.opc"
11529                       int im AU = (op[1] >> 2) & 0x03;
11530 #line 450 "rx-decode.opc"
11531                       int rdst AU = op[2] & 0x0f;
11532                       if (trace)
11533                         {
11534                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11535                                  "/** 1111 1101 0111 im00 1101rdst      xor     #%1, %0 */",
11536                                  op[0], op[1], op[2]);
11537                           printf ("  im = 0x%x,", im);
11538                           printf ("  rdst = 0x%x\n", rdst);
11539                         }
11540                       SYNTAX("xor       #%1, %0");
11541 #line 450 "rx-decode.opc"
11542                       ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
11543
11544                     }
11545                   break;
11546                 case 0xe0:
11547                   op_semantics_107:
11548                     {
11549                       /** 1111 1101 0111 im00 1110rdst  stz     #%1, %0 */
11550 #line 396 "rx-decode.opc"
11551                       int im AU = (op[1] >> 2) & 0x03;
11552 #line 396 "rx-decode.opc"
11553                       int rdst AU = op[2] & 0x0f;
11554                       if (trace)
11555                         {
11556                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11557                                  "/** 1111 1101 0111 im00 1110rdst      stz     #%1, %0 */",
11558                                  op[0], op[1], op[2]);
11559                           printf ("  im = 0x%x,", im);
11560                           printf ("  rdst = 0x%x\n", rdst);
11561                         }
11562                       SYNTAX("stz       #%1, %0");
11563 #line 396 "rx-decode.opc"
11564                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
11565
11566                     }
11567                   break;
11568                 case 0xf0:
11569                   op_semantics_108:
11570                     {
11571                       /** 1111 1101 0111 im00 1111rdst  stnz    #%1, %0 */
11572 #line 399 "rx-decode.opc"
11573                       int im AU = (op[1] >> 2) & 0x03;
11574 #line 399 "rx-decode.opc"
11575                       int rdst AU = op[2] & 0x0f;
11576                       if (trace)
11577                         {
11578                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11579                                  "/** 1111 1101 0111 im00 1111rdst      stnz    #%1, %0 */",
11580                                  op[0], op[1], op[2]);
11581                           printf ("  im = 0x%x,", im);
11582                           printf ("  rdst = 0x%x\n", rdst);
11583                         }
11584                       SYNTAX("stnz      #%1, %0");
11585 #line 399 "rx-decode.opc"
11586                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
11587
11588                     /*----------------------------------------------------------------------*/
11589                     /* RTSD                                                                     */
11590
11591                     }
11592                   break;
11593                 default: UNSUPPORTED(); break;
11594               }
11595             break;
11596           case 0x72:
11597               GETBYTE ();
11598               switch (op[2] & 0xf0)
11599               {
11600                 case 0x00:
11601                     {
11602                       /** 1111 1101 0111 0010 0000 rdst fsub    #%1, %0 */
11603 #line 906 "rx-decode.opc"
11604                       int rdst AU = op[2] & 0x0f;
11605                       if (trace)
11606                         {
11607                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11608                                  "/** 1111 1101 0111 0010 0000 rdst     fsub    #%1, %0 */",
11609                                  op[0], op[1], op[2]);
11610                           printf ("  rdst = 0x%x\n", rdst);
11611                         }
11612                       SYNTAX("fsub      #%1, %0");
11613 #line 906 "rx-decode.opc"
11614                       ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
11615
11616                     }
11617                   break;
11618                 case 0x10:
11619                     {
11620                       /** 1111 1101 0111 0010 0001 rdst fcmp    #%1, %0 */
11621 #line 900 "rx-decode.opc"
11622                       int rdst AU = op[2] & 0x0f;
11623                       if (trace)
11624                         {
11625                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11626                                  "/** 1111 1101 0111 0010 0001 rdst     fcmp    #%1, %0 */",
11627                                  op[0], op[1], op[2]);
11628                           printf ("  rdst = 0x%x\n", rdst);
11629                         }
11630                       SYNTAX("fcmp      #%1, %0");
11631 #line 900 "rx-decode.opc"
11632                       ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
11633
11634                     }
11635                   break;
11636                 case 0x20:
11637                     {
11638                       /** 1111 1101 0111 0010 0010 rdst fadd    #%1, %0 */
11639 #line 894 "rx-decode.opc"
11640                       int rdst AU = op[2] & 0x0f;
11641                       if (trace)
11642                         {
11643                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11644                                  "/** 1111 1101 0111 0010 0010 rdst     fadd    #%1, %0 */",
11645                                  op[0], op[1], op[2]);
11646                           printf ("  rdst = 0x%x\n", rdst);
11647                         }
11648                       SYNTAX("fadd      #%1, %0");
11649 #line 894 "rx-decode.opc"
11650                       ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
11651
11652                     }
11653                   break;
11654                 case 0x30:
11655                     {
11656                       /** 1111 1101 0111 0010 0011 rdst fmul    #%1, %0 */
11657 #line 915 "rx-decode.opc"
11658                       int rdst AU = op[2] & 0x0f;
11659                       if (trace)
11660                         {
11661                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11662                                  "/** 1111 1101 0111 0010 0011 rdst     fmul    #%1, %0 */",
11663                                  op[0], op[1], op[2]);
11664                           printf ("  rdst = 0x%x\n", rdst);
11665                         }
11666                       SYNTAX("fmul      #%1, %0");
11667 #line 915 "rx-decode.opc"
11668                       ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
11669
11670                     }
11671                   break;
11672                 case 0x40:
11673                     {
11674                       /** 1111 1101 0111 0010 0100 rdst fdiv    #%1, %0 */
11675 #line 921 "rx-decode.opc"
11676                       int rdst AU = op[2] & 0x0f;
11677                       if (trace)
11678                         {
11679                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11680                                  "/** 1111 1101 0111 0010 0100 rdst     fdiv    #%1, %0 */",
11681                                  op[0], op[1], op[2]);
11682                           printf ("  rdst = 0x%x\n", rdst);
11683                         }
11684                       SYNTAX("fdiv      #%1, %0");
11685 #line 921 "rx-decode.opc"
11686                       ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
11687
11688                     }
11689                   break;
11690                 default: UNSUPPORTED(); break;
11691               }
11692             break;
11693           case 0x73:
11694               GETBYTE ();
11695               switch (op[2] & 0xe0)
11696               {
11697                 case 0x00:
11698                   op_semantics_109:
11699                     {
11700                       /** 1111 1101 0111 im11 000crdst  mvtc    #%1, %0 */
11701 #line 1011 "rx-decode.opc"
11702                       int im AU = (op[1] >> 2) & 0x03;
11703 #line 1011 "rx-decode.opc"
11704                       int crdst AU = op[2] & 0x1f;
11705                       if (trace)
11706                         {
11707                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11708                                  "/** 1111 1101 0111 im11 000crdst      mvtc    #%1, %0 */",
11709                                  op[0], op[1], op[2]);
11710                           printf ("  im = 0x%x,", im);
11711                           printf ("  crdst = 0x%x\n", crdst);
11712                         }
11713                       SYNTAX("mvtc      #%1, %0");
11714 #line 1011 "rx-decode.opc"
11715                       ID(mov); SC(IMMex(im)); DR(crdst + 16);
11716
11717                     }
11718                   break;
11719                 default: UNSUPPORTED(); break;
11720               }
11721             break;
11722           case 0x74:
11723               GETBYTE ();
11724               switch (op[2] & 0xf0)
11725               {
11726                 case 0x20:
11727                   goto op_semantics_98;
11728                   break;
11729                 case 0x40:
11730                   goto op_semantics_99;
11731                   break;
11732                 case 0x50:
11733                   goto op_semantics_100;
11734                   break;
11735                 case 0x60:
11736                   goto op_semantics_101;
11737                   break;
11738                 case 0x70:
11739                   goto op_semantics_102;
11740                   break;
11741                 case 0x80:
11742                   goto op_semantics_103;
11743                   break;
11744                 case 0x90:
11745                   goto op_semantics_104;
11746                   break;
11747                 case 0xc0:
11748                   goto op_semantics_105;
11749                   break;
11750                 case 0xd0:
11751                   goto op_semantics_106;
11752                   break;
11753                 case 0xe0:
11754                   goto op_semantics_107;
11755                   break;
11756                 case 0xf0:
11757                   goto op_semantics_108;
11758                   break;
11759                 default: UNSUPPORTED(); break;
11760               }
11761             break;
11762           case 0x77:
11763               GETBYTE ();
11764               switch (op[2] & 0xe0)
11765               {
11766                 case 0x00:
11767                   goto op_semantics_109;
11768                   break;
11769                 default: UNSUPPORTED(); break;
11770               }
11771             break;
11772           case 0x78:
11773               GETBYTE ();
11774               switch (op[2] & 0xf0)
11775               {
11776                 case 0x20:
11777                   goto op_semantics_98;
11778                   break;
11779                 case 0x40:
11780                   goto op_semantics_99;
11781                   break;
11782                 case 0x50:
11783                   goto op_semantics_100;
11784                   break;
11785                 case 0x60:
11786                   goto op_semantics_101;
11787                   break;
11788                 case 0x70:
11789                   goto op_semantics_102;
11790                   break;
11791                 case 0x80:
11792                   goto op_semantics_103;
11793                   break;
11794                 case 0x90:
11795                   goto op_semantics_104;
11796                   break;
11797                 case 0xc0:
11798                   goto op_semantics_105;
11799                   break;
11800                 case 0xd0:
11801                   goto op_semantics_106;
11802                   break;
11803                 case 0xe0:
11804                   goto op_semantics_107;
11805                   break;
11806                 case 0xf0:
11807                   goto op_semantics_108;
11808                   break;
11809                 default: UNSUPPORTED(); break;
11810               }
11811             break;
11812           case 0x7b:
11813               GETBYTE ();
11814               switch (op[2] & 0xe0)
11815               {
11816                 case 0x00:
11817                   goto op_semantics_109;
11818                   break;
11819                 default: UNSUPPORTED(); break;
11820               }
11821             break;
11822           case 0x7c:
11823               GETBYTE ();
11824               switch (op[2] & 0xf0)
11825               {
11826                 case 0x20:
11827                   goto op_semantics_98;
11828                   break;
11829                 case 0x40:
11830                   goto op_semantics_99;
11831                   break;
11832                 case 0x50:
11833                   goto op_semantics_100;
11834                   break;
11835                 case 0x60:
11836                   goto op_semantics_101;
11837                   break;
11838                 case 0x70:
11839                   goto op_semantics_102;
11840                   break;
11841                 case 0x80:
11842                   goto op_semantics_103;
11843                   break;
11844                 case 0x90:
11845                   goto op_semantics_104;
11846                   break;
11847                 case 0xc0:
11848                   goto op_semantics_105;
11849                   break;
11850                 case 0xd0:
11851                   goto op_semantics_106;
11852                   break;
11853                 case 0xe0:
11854                   goto op_semantics_107;
11855                   break;
11856                 case 0xf0:
11857                   goto op_semantics_108;
11858                   break;
11859                 default: UNSUPPORTED(); break;
11860               }
11861             break;
11862           case 0x7f:
11863               GETBYTE ();
11864               switch (op[2] & 0xe0)
11865               {
11866                 case 0x00:
11867                   goto op_semantics_109;
11868                   break;
11869                 default: UNSUPPORTED(); break;
11870               }
11871             break;
11872           case 0x80:
11873               GETBYTE ();
11874               switch (op[2] & 0x00)
11875               {
11876                 case 0x00:
11877                   op_semantics_110:
11878                     {
11879                       /** 1111 1101 100immmm rsrc rdst  shlr    #%2, %1, %0 */
11880 #line 736 "rx-decode.opc"
11881                       int immmm AU = op[1] & 0x1f;
11882 #line 736 "rx-decode.opc"
11883                       int rsrc AU = (op[2] >> 4) & 0x0f;
11884 #line 736 "rx-decode.opc"
11885                       int rdst AU = op[2] & 0x0f;
11886                       if (trace)
11887                         {
11888                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11889                                  "/** 1111 1101 100immmm rsrc rdst      shlr    #%2, %1, %0 */",
11890                                  op[0], op[1], op[2]);
11891                           printf ("  immmm = 0x%x,", immmm);
11892                           printf ("  rsrc = 0x%x,", rsrc);
11893                           printf ("  rdst = 0x%x\n", rdst);
11894                         }
11895                       SYNTAX("shlr      #%2, %1, %0");
11896 #line 736 "rx-decode.opc"
11897                       ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
11898
11899                     /*----------------------------------------------------------------------*/
11900                     /* ROTATE                                                           */
11901
11902                     }
11903                   break;
11904               }
11905             break;
11906           case 0x81:
11907               GETBYTE ();
11908               switch (op[2] & 0x00)
11909               {
11910                 case 0x00:
11911                   goto op_semantics_110;
11912                   break;
11913               }
11914             break;
11915           case 0x82:
11916               GETBYTE ();
11917               switch (op[2] & 0x00)
11918               {
11919                 case 0x00:
11920                   goto op_semantics_110;
11921                   break;
11922               }
11923             break;
11924           case 0x83:
11925               GETBYTE ();
11926               switch (op[2] & 0x00)
11927               {
11928                 case 0x00:
11929                   goto op_semantics_110;
11930                   break;
11931               }
11932             break;
11933           case 0x84:
11934               GETBYTE ();
11935               switch (op[2] & 0x00)
11936               {
11937                 case 0x00:
11938                   goto op_semantics_110;
11939                   break;
11940               }
11941             break;
11942           case 0x85:
11943               GETBYTE ();
11944               switch (op[2] & 0x00)
11945               {
11946                 case 0x00:
11947                   goto op_semantics_110;
11948                   break;
11949               }
11950             break;
11951           case 0x86:
11952               GETBYTE ();
11953               switch (op[2] & 0x00)
11954               {
11955                 case 0x00:
11956                   goto op_semantics_110;
11957                   break;
11958               }
11959             break;
11960           case 0x87:
11961               GETBYTE ();
11962               switch (op[2] & 0x00)
11963               {
11964                 case 0x00:
11965                   goto op_semantics_110;
11966                   break;
11967               }
11968             break;
11969           case 0x88:
11970               GETBYTE ();
11971               switch (op[2] & 0x00)
11972               {
11973                 case 0x00:
11974                   goto op_semantics_110;
11975                   break;
11976               }
11977             break;
11978           case 0x89:
11979               GETBYTE ();
11980               switch (op[2] & 0x00)
11981               {
11982                 case 0x00:
11983                   goto op_semantics_110;
11984                   break;
11985               }
11986             break;
11987           case 0x8a:
11988               GETBYTE ();
11989               switch (op[2] & 0x00)
11990               {
11991                 case 0x00:
11992                   goto op_semantics_110;
11993                   break;
11994               }
11995             break;
11996           case 0x8b:
11997               GETBYTE ();
11998               switch (op[2] & 0x00)
11999               {
12000                 case 0x00:
12001                   goto op_semantics_110;
12002                   break;
12003               }
12004             break;
12005           case 0x8c:
12006               GETBYTE ();
12007               switch (op[2] & 0x00)
12008               {
12009                 case 0x00:
12010                   goto op_semantics_110;
12011                   break;
12012               }
12013             break;
12014           case 0x8d:
12015               GETBYTE ();
12016               switch (op[2] & 0x00)
12017               {
12018                 case 0x00:
12019                   goto op_semantics_110;
12020                   break;
12021               }
12022             break;
12023           case 0x8e:
12024               GETBYTE ();
12025               switch (op[2] & 0x00)
12026               {
12027                 case 0x00:
12028                   goto op_semantics_110;
12029                   break;
12030               }
12031             break;
12032           case 0x8f:
12033               GETBYTE ();
12034               switch (op[2] & 0x00)
12035               {
12036                 case 0x00:
12037                   goto op_semantics_110;
12038                   break;
12039               }
12040             break;
12041           case 0x90:
12042               GETBYTE ();
12043               switch (op[2] & 0x00)
12044               {
12045                 case 0x00:
12046                   goto op_semantics_110;
12047                   break;
12048               }
12049             break;
12050           case 0x91:
12051               GETBYTE ();
12052               switch (op[2] & 0x00)
12053               {
12054                 case 0x00:
12055                   goto op_semantics_110;
12056                   break;
12057               }
12058             break;
12059           case 0x92:
12060               GETBYTE ();
12061               switch (op[2] & 0x00)
12062               {
12063                 case 0x00:
12064                   goto op_semantics_110;
12065                   break;
12066               }
12067             break;
12068           case 0x93:
12069               GETBYTE ();
12070               switch (op[2] & 0x00)
12071               {
12072                 case 0x00:
12073                   goto op_semantics_110;
12074                   break;
12075               }
12076             break;
12077           case 0x94:
12078               GETBYTE ();
12079               switch (op[2] & 0x00)
12080               {
12081                 case 0x00:
12082                   goto op_semantics_110;
12083                   break;
12084               }
12085             break;
12086           case 0x95:
12087               GETBYTE ();
12088               switch (op[2] & 0x00)
12089               {
12090                 case 0x00:
12091                   goto op_semantics_110;
12092                   break;
12093               }
12094             break;
12095           case 0x96:
12096               GETBYTE ();
12097               switch (op[2] & 0x00)
12098               {
12099                 case 0x00:
12100                   goto op_semantics_110;
12101                   break;
12102               }
12103             break;
12104           case 0x97:
12105               GETBYTE ();
12106               switch (op[2] & 0x00)
12107               {
12108                 case 0x00:
12109                   goto op_semantics_110;
12110                   break;
12111               }
12112             break;
12113           case 0x98:
12114               GETBYTE ();
12115               switch (op[2] & 0x00)
12116               {
12117                 case 0x00:
12118                   goto op_semantics_110;
12119                   break;
12120               }
12121             break;
12122           case 0x99:
12123               GETBYTE ();
12124               switch (op[2] & 0x00)
12125               {
12126                 case 0x00:
12127                   goto op_semantics_110;
12128                   break;
12129               }
12130             break;
12131           case 0x9a:
12132               GETBYTE ();
12133               switch (op[2] & 0x00)
12134               {
12135                 case 0x00:
12136                   goto op_semantics_110;
12137                   break;
12138               }
12139             break;
12140           case 0x9b:
12141               GETBYTE ();
12142               switch (op[2] & 0x00)
12143               {
12144                 case 0x00:
12145                   goto op_semantics_110;
12146                   break;
12147               }
12148             break;
12149           case 0x9c:
12150               GETBYTE ();
12151               switch (op[2] & 0x00)
12152               {
12153                 case 0x00:
12154                   goto op_semantics_110;
12155                   break;
12156               }
12157             break;
12158           case 0x9d:
12159               GETBYTE ();
12160               switch (op[2] & 0x00)
12161               {
12162                 case 0x00:
12163                   goto op_semantics_110;
12164                   break;
12165               }
12166             break;
12167           case 0x9e:
12168               GETBYTE ();
12169               switch (op[2] & 0x00)
12170               {
12171                 case 0x00:
12172                   goto op_semantics_110;
12173                   break;
12174               }
12175             break;
12176           case 0x9f:
12177               GETBYTE ();
12178               switch (op[2] & 0x00)
12179               {
12180                 case 0x00:
12181                   goto op_semantics_110;
12182                   break;
12183               }
12184             break;
12185           case 0xa0:
12186               GETBYTE ();
12187               switch (op[2] & 0x00)
12188               {
12189                 case 0x00:
12190                   op_semantics_111:
12191                     {
12192                       /** 1111 1101 101immmm rsrc rdst  shar    #%2, %1, %0 */
12193 #line 726 "rx-decode.opc"
12194                       int immmm AU = op[1] & 0x1f;
12195 #line 726 "rx-decode.opc"
12196                       int rsrc AU = (op[2] >> 4) & 0x0f;
12197 #line 726 "rx-decode.opc"
12198                       int rdst AU = op[2] & 0x0f;
12199                       if (trace)
12200                         {
12201                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12202                                  "/** 1111 1101 101immmm rsrc rdst      shar    #%2, %1, %0 */",
12203                                  op[0], op[1], op[2]);
12204                           printf ("  immmm = 0x%x,", immmm);
12205                           printf ("  rsrc = 0x%x,", rsrc);
12206                           printf ("  rdst = 0x%x\n", rdst);
12207                         }
12208                       SYNTAX("shar      #%2, %1, %0");
12209 #line 726 "rx-decode.opc"
12210                       ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
12211
12212
12213                     }
12214                   break;
12215               }
12216             break;
12217           case 0xa1:
12218               GETBYTE ();
12219               switch (op[2] & 0x00)
12220               {
12221                 case 0x00:
12222                   goto op_semantics_111;
12223                   break;
12224               }
12225             break;
12226           case 0xa2:
12227               GETBYTE ();
12228               switch (op[2] & 0x00)
12229               {
12230                 case 0x00:
12231                   goto op_semantics_111;
12232                   break;
12233               }
12234             break;
12235           case 0xa3:
12236               GETBYTE ();
12237               switch (op[2] & 0x00)
12238               {
12239                 case 0x00:
12240                   goto op_semantics_111;
12241                   break;
12242               }
12243             break;
12244           case 0xa4:
12245               GETBYTE ();
12246               switch (op[2] & 0x00)
12247               {
12248                 case 0x00:
12249                   goto op_semantics_111;
12250                   break;
12251               }
12252             break;
12253           case 0xa5:
12254               GETBYTE ();
12255               switch (op[2] & 0x00)
12256               {
12257                 case 0x00:
12258                   goto op_semantics_111;
12259                   break;
12260               }
12261             break;
12262           case 0xa6:
12263               GETBYTE ();
12264               switch (op[2] & 0x00)
12265               {
12266                 case 0x00:
12267                   goto op_semantics_111;
12268                   break;
12269               }
12270             break;
12271           case 0xa7:
12272               GETBYTE ();
12273               switch (op[2] & 0x00)
12274               {
12275                 case 0x00:
12276                   goto op_semantics_111;
12277                   break;
12278               }
12279             break;
12280           case 0xa8:
12281               GETBYTE ();
12282               switch (op[2] & 0x00)
12283               {
12284                 case 0x00:
12285                   goto op_semantics_111;
12286                   break;
12287               }
12288             break;
12289           case 0xa9:
12290               GETBYTE ();
12291               switch (op[2] & 0x00)
12292               {
12293                 case 0x00:
12294                   goto op_semantics_111;
12295                   break;
12296               }
12297             break;
12298           case 0xaa:
12299               GETBYTE ();
12300               switch (op[2] & 0x00)
12301               {
12302                 case 0x00:
12303                   goto op_semantics_111;
12304                   break;
12305               }
12306             break;
12307           case 0xab:
12308               GETBYTE ();
12309               switch (op[2] & 0x00)
12310               {
12311                 case 0x00:
12312                   goto op_semantics_111;
12313                   break;
12314               }
12315             break;
12316           case 0xac:
12317               GETBYTE ();
12318               switch (op[2] & 0x00)
12319               {
12320                 case 0x00:
12321                   goto op_semantics_111;
12322                   break;
12323               }
12324             break;
12325           case 0xad:
12326               GETBYTE ();
12327               switch (op[2] & 0x00)
12328               {
12329                 case 0x00:
12330                   goto op_semantics_111;
12331                   break;
12332               }
12333             break;
12334           case 0xae:
12335               GETBYTE ();
12336               switch (op[2] & 0x00)
12337               {
12338                 case 0x00:
12339                   goto op_semantics_111;
12340                   break;
12341               }
12342             break;
12343           case 0xaf:
12344               GETBYTE ();
12345               switch (op[2] & 0x00)
12346               {
12347                 case 0x00:
12348                   goto op_semantics_111;
12349                   break;
12350               }
12351             break;
12352           case 0xb0:
12353               GETBYTE ();
12354               switch (op[2] & 0x00)
12355               {
12356                 case 0x00:
12357                   goto op_semantics_111;
12358                   break;
12359               }
12360             break;
12361           case 0xb1:
12362               GETBYTE ();
12363               switch (op[2] & 0x00)
12364               {
12365                 case 0x00:
12366                   goto op_semantics_111;
12367                   break;
12368               }
12369             break;
12370           case 0xb2:
12371               GETBYTE ();
12372               switch (op[2] & 0x00)
12373               {
12374                 case 0x00:
12375                   goto op_semantics_111;
12376                   break;
12377               }
12378             break;
12379           case 0xb3:
12380               GETBYTE ();
12381               switch (op[2] & 0x00)
12382               {
12383                 case 0x00:
12384                   goto op_semantics_111;
12385                   break;
12386               }
12387             break;
12388           case 0xb4:
12389               GETBYTE ();
12390               switch (op[2] & 0x00)
12391               {
12392                 case 0x00:
12393                   goto op_semantics_111;
12394                   break;
12395               }
12396             break;
12397           case 0xb5:
12398               GETBYTE ();
12399               switch (op[2] & 0x00)
12400               {
12401                 case 0x00:
12402                   goto op_semantics_111;
12403                   break;
12404               }
12405             break;
12406           case 0xb6:
12407               GETBYTE ();
12408               switch (op[2] & 0x00)
12409               {
12410                 case 0x00:
12411                   goto op_semantics_111;
12412                   break;
12413               }
12414             break;
12415           case 0xb7:
12416               GETBYTE ();
12417               switch (op[2] & 0x00)
12418               {
12419                 case 0x00:
12420                   goto op_semantics_111;
12421                   break;
12422               }
12423             break;
12424           case 0xb8:
12425               GETBYTE ();
12426               switch (op[2] & 0x00)
12427               {
12428                 case 0x00:
12429                   goto op_semantics_111;
12430                   break;
12431               }
12432             break;
12433           case 0xb9:
12434               GETBYTE ();
12435               switch (op[2] & 0x00)
12436               {
12437                 case 0x00:
12438                   goto op_semantics_111;
12439                   break;
12440               }
12441             break;
12442           case 0xba:
12443               GETBYTE ();
12444               switch (op[2] & 0x00)
12445               {
12446                 case 0x00:
12447                   goto op_semantics_111;
12448                   break;
12449               }
12450             break;
12451           case 0xbb:
12452               GETBYTE ();
12453               switch (op[2] & 0x00)
12454               {
12455                 case 0x00:
12456                   goto op_semantics_111;
12457                   break;
12458               }
12459             break;
12460           case 0xbc:
12461               GETBYTE ();
12462               switch (op[2] & 0x00)
12463               {
12464                 case 0x00:
12465                   goto op_semantics_111;
12466                   break;
12467               }
12468             break;
12469           case 0xbd:
12470               GETBYTE ();
12471               switch (op[2] & 0x00)
12472               {
12473                 case 0x00:
12474                   goto op_semantics_111;
12475                   break;
12476               }
12477             break;
12478           case 0xbe:
12479               GETBYTE ();
12480               switch (op[2] & 0x00)
12481               {
12482                 case 0x00:
12483                   goto op_semantics_111;
12484                   break;
12485               }
12486             break;
12487           case 0xbf:
12488               GETBYTE ();
12489               switch (op[2] & 0x00)
12490               {
12491                 case 0x00:
12492                   goto op_semantics_111;
12493                   break;
12494               }
12495             break;
12496           case 0xc0:
12497               GETBYTE ();
12498               switch (op[2] & 0x00)
12499               {
12500                 case 0x00:
12501                   op_semantics_112:
12502                     {
12503                       /** 1111 1101 110immmm rsrc rdst  shll    #%2, %1, %0 */
12504 #line 716 "rx-decode.opc"
12505                       int immmm AU = op[1] & 0x1f;
12506 #line 716 "rx-decode.opc"
12507                       int rsrc AU = (op[2] >> 4) & 0x0f;
12508 #line 716 "rx-decode.opc"
12509                       int rdst AU = op[2] & 0x0f;
12510                       if (trace)
12511                         {
12512                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12513                                  "/** 1111 1101 110immmm rsrc rdst      shll    #%2, %1, %0 */",
12514                                  op[0], op[1], op[2]);
12515                           printf ("  immmm = 0x%x,", immmm);
12516                           printf ("  rsrc = 0x%x,", rsrc);
12517                           printf ("  rdst = 0x%x\n", rdst);
12518                         }
12519                       SYNTAX("shll      #%2, %1, %0");
12520 #line 716 "rx-decode.opc"
12521                       ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
12522
12523
12524                     }
12525                   break;
12526               }
12527             break;
12528           case 0xc1:
12529               GETBYTE ();
12530               switch (op[2] & 0x00)
12531               {
12532                 case 0x00:
12533                   goto op_semantics_112;
12534                   break;
12535               }
12536             break;
12537           case 0xc2:
12538               GETBYTE ();
12539               switch (op[2] & 0x00)
12540               {
12541                 case 0x00:
12542                   goto op_semantics_112;
12543                   break;
12544               }
12545             break;
12546           case 0xc3:
12547               GETBYTE ();
12548               switch (op[2] & 0x00)
12549               {
12550                 case 0x00:
12551                   goto op_semantics_112;
12552                   break;
12553               }
12554             break;
12555           case 0xc4:
12556               GETBYTE ();
12557               switch (op[2] & 0x00)
12558               {
12559                 case 0x00:
12560                   goto op_semantics_112;
12561                   break;
12562               }
12563             break;
12564           case 0xc5:
12565               GETBYTE ();
12566               switch (op[2] & 0x00)
12567               {
12568                 case 0x00:
12569                   goto op_semantics_112;
12570                   break;
12571               }
12572             break;
12573           case 0xc6:
12574               GETBYTE ();
12575               switch (op[2] & 0x00)
12576               {
12577                 case 0x00:
12578                   goto op_semantics_112;
12579                   break;
12580               }
12581             break;
12582           case 0xc7:
12583               GETBYTE ();
12584               switch (op[2] & 0x00)
12585               {
12586                 case 0x00:
12587                   goto op_semantics_112;
12588                   break;
12589               }
12590             break;
12591           case 0xc8:
12592               GETBYTE ();
12593               switch (op[2] & 0x00)
12594               {
12595                 case 0x00:
12596                   goto op_semantics_112;
12597                   break;
12598               }
12599             break;
12600           case 0xc9:
12601               GETBYTE ();
12602               switch (op[2] & 0x00)
12603               {
12604                 case 0x00:
12605                   goto op_semantics_112;
12606                   break;
12607               }
12608             break;
12609           case 0xca:
12610               GETBYTE ();
12611               switch (op[2] & 0x00)
12612               {
12613                 case 0x00:
12614                   goto op_semantics_112;
12615                   break;
12616               }
12617             break;
12618           case 0xcb:
12619               GETBYTE ();
12620               switch (op[2] & 0x00)
12621               {
12622                 case 0x00:
12623                   goto op_semantics_112;
12624                   break;
12625               }
12626             break;
12627           case 0xcc:
12628               GETBYTE ();
12629               switch (op[2] & 0x00)
12630               {
12631                 case 0x00:
12632                   goto op_semantics_112;
12633                   break;
12634               }
12635             break;
12636           case 0xcd:
12637               GETBYTE ();
12638               switch (op[2] & 0x00)
12639               {
12640                 case 0x00:
12641                   goto op_semantics_112;
12642                   break;
12643               }
12644             break;
12645           case 0xce:
12646               GETBYTE ();
12647               switch (op[2] & 0x00)
12648               {
12649                 case 0x00:
12650                   goto op_semantics_112;
12651                   break;
12652               }
12653             break;
12654           case 0xcf:
12655               GETBYTE ();
12656               switch (op[2] & 0x00)
12657               {
12658                 case 0x00:
12659                   goto op_semantics_112;
12660                   break;
12661               }
12662             break;
12663           case 0xd0:
12664               GETBYTE ();
12665               switch (op[2] & 0x00)
12666               {
12667                 case 0x00:
12668                   goto op_semantics_112;
12669                   break;
12670               }
12671             break;
12672           case 0xd1:
12673               GETBYTE ();
12674               switch (op[2] & 0x00)
12675               {
12676                 case 0x00:
12677                   goto op_semantics_112;
12678                   break;
12679               }
12680             break;
12681           case 0xd2:
12682               GETBYTE ();
12683               switch (op[2] & 0x00)
12684               {
12685                 case 0x00:
12686                   goto op_semantics_112;
12687                   break;
12688               }
12689             break;
12690           case 0xd3:
12691               GETBYTE ();
12692               switch (op[2] & 0x00)
12693               {
12694                 case 0x00:
12695                   goto op_semantics_112;
12696                   break;
12697               }
12698             break;
12699           case 0xd4:
12700               GETBYTE ();
12701               switch (op[2] & 0x00)
12702               {
12703                 case 0x00:
12704                   goto op_semantics_112;
12705                   break;
12706               }
12707             break;
12708           case 0xd5:
12709               GETBYTE ();
12710               switch (op[2] & 0x00)
12711               {
12712                 case 0x00:
12713                   goto op_semantics_112;
12714                   break;
12715               }
12716             break;
12717           case 0xd6:
12718               GETBYTE ();
12719               switch (op[2] & 0x00)
12720               {
12721                 case 0x00:
12722                   goto op_semantics_112;
12723                   break;
12724               }
12725             break;
12726           case 0xd7:
12727               GETBYTE ();
12728               switch (op[2] & 0x00)
12729               {
12730                 case 0x00:
12731                   goto op_semantics_112;
12732                   break;
12733               }
12734             break;
12735           case 0xd8:
12736               GETBYTE ();
12737               switch (op[2] & 0x00)
12738               {
12739                 case 0x00:
12740                   goto op_semantics_112;
12741                   break;
12742               }
12743             break;
12744           case 0xd9:
12745               GETBYTE ();
12746               switch (op[2] & 0x00)
12747               {
12748                 case 0x00:
12749                   goto op_semantics_112;
12750                   break;
12751               }
12752             break;
12753           case 0xda:
12754               GETBYTE ();
12755               switch (op[2] & 0x00)
12756               {
12757                 case 0x00:
12758                   goto op_semantics_112;
12759                   break;
12760               }
12761             break;
12762           case 0xdb:
12763               GETBYTE ();
12764               switch (op[2] & 0x00)
12765               {
12766                 case 0x00:
12767                   goto op_semantics_112;
12768                   break;
12769               }
12770             break;
12771           case 0xdc:
12772               GETBYTE ();
12773               switch (op[2] & 0x00)
12774               {
12775                 case 0x00:
12776                   goto op_semantics_112;
12777                   break;
12778               }
12779             break;
12780           case 0xdd:
12781               GETBYTE ();
12782               switch (op[2] & 0x00)
12783               {
12784                 case 0x00:
12785                   goto op_semantics_112;
12786                   break;
12787               }
12788             break;
12789           case 0xde:
12790               GETBYTE ();
12791               switch (op[2] & 0x00)
12792               {
12793                 case 0x00:
12794                   goto op_semantics_112;
12795                   break;
12796               }
12797             break;
12798           case 0xdf:
12799               GETBYTE ();
12800               switch (op[2] & 0x00)
12801               {
12802                 case 0x00:
12803                   goto op_semantics_112;
12804                   break;
12805               }
12806             break;
12807           case 0xe0:
12808               GETBYTE ();
12809               switch (op[2] & 0xf0)
12810               {
12811                 case 0x00:
12812                 case 0x10:
12813                 case 0x20:
12814                 case 0x30:
12815                 case 0x40:
12816                 case 0x50:
12817                 case 0x60:
12818                 case 0x70:
12819                 case 0x80:
12820                 case 0x90:
12821                 case 0xa0:
12822                 case 0xb0:
12823                 case 0xc0:
12824                 case 0xd0:
12825                 case 0xe0:
12826                   op_semantics_113:
12827                     {
12828                       /** 1111 1101 111 bittt cond rdst bm%2    #%1, %0%S0 */
12829 #line 990 "rx-decode.opc"
12830                       int bittt AU = op[1] & 0x1f;
12831 #line 990 "rx-decode.opc"
12832                       int cond AU = (op[2] >> 4) & 0x0f;
12833 #line 990 "rx-decode.opc"
12834                       int rdst AU = op[2] & 0x0f;
12835                       if (trace)
12836                         {
12837                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12838                                  "/** 1111 1101 111 bittt cond rdst     bm%2    #%1, %0%S0 */",
12839                                  op[0], op[1], op[2]);
12840                           printf ("  bittt = 0x%x,", bittt);
12841                           printf ("  cond = 0x%x,", cond);
12842                           printf ("  rdst = 0x%x\n", rdst);
12843                         }
12844                       SYNTAX("bm%2      #%1, %0%S0");
12845 #line 990 "rx-decode.opc"
12846                       ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
12847
12848                     /*----------------------------------------------------------------------*/
12849                     /* CONTROL REGISTERS                                                        */
12850
12851                     }
12852                   break;
12853                 case 0xf0:
12854                   op_semantics_114:
12855                     {
12856                       /** 1111 1101 111bittt 1111 rdst  bnot    #%1, %0 */
12857 #line 983 "rx-decode.opc"
12858                       int bittt AU = op[1] & 0x1f;
12859 #line 983 "rx-decode.opc"
12860                       int rdst AU = op[2] & 0x0f;
12861                       if (trace)
12862                         {
12863                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12864                                  "/** 1111 1101 111bittt 1111 rdst      bnot    #%1, %0 */",
12865                                  op[0], op[1], op[2]);
12866                           printf ("  bittt = 0x%x,", bittt);
12867                           printf ("  rdst = 0x%x\n", rdst);
12868                         }
12869                       SYNTAX("bnot      #%1, %0");
12870 #line 983 "rx-decode.opc"
12871                       ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
12872
12873
12874                     }
12875                   break;
12876               }
12877             break;
12878           case 0xe1:
12879               GETBYTE ();
12880               switch (op[2] & 0xf0)
12881               {
12882                 case 0x00:
12883                 case 0x10:
12884                 case 0x20:
12885                 case 0x30:
12886                 case 0x40:
12887                 case 0x50:
12888                 case 0x60:
12889                 case 0x70:
12890                 case 0x80:
12891                 case 0x90:
12892                 case 0xa0:
12893                 case 0xb0:
12894                 case 0xc0:
12895                 case 0xd0:
12896                 case 0xe0:
12897                   goto op_semantics_113;
12898                   break;
12899                 case 0xf0:
12900                   goto op_semantics_114;
12901                   break;
12902               }
12903             break;
12904           case 0xe2:
12905               GETBYTE ();
12906               switch (op[2] & 0xf0)
12907               {
12908                 case 0x00:
12909                 case 0x10:
12910                 case 0x20:
12911                 case 0x30:
12912                 case 0x40:
12913                 case 0x50:
12914                 case 0x60:
12915                 case 0x70:
12916                 case 0x80:
12917                 case 0x90:
12918                 case 0xa0:
12919                 case 0xb0:
12920                 case 0xc0:
12921                 case 0xd0:
12922                 case 0xe0:
12923                   goto op_semantics_113;
12924                   break;
12925                 case 0xf0:
12926                   goto op_semantics_114;
12927                   break;
12928               }
12929             break;
12930           case 0xe3:
12931               GETBYTE ();
12932               switch (op[2] & 0xf0)
12933               {
12934                 case 0x00:
12935                 case 0x10:
12936                 case 0x20:
12937                 case 0x30:
12938                 case 0x40:
12939                 case 0x50:
12940                 case 0x60:
12941                 case 0x70:
12942                 case 0x80:
12943                 case 0x90:
12944                 case 0xa0:
12945                 case 0xb0:
12946                 case 0xc0:
12947                 case 0xd0:
12948                 case 0xe0:
12949                   goto op_semantics_113;
12950                   break;
12951                 case 0xf0:
12952                   goto op_semantics_114;
12953                   break;
12954               }
12955             break;
12956           case 0xe4:
12957               GETBYTE ();
12958               switch (op[2] & 0xf0)
12959               {
12960                 case 0x00:
12961                 case 0x10:
12962                 case 0x20:
12963                 case 0x30:
12964                 case 0x40:
12965                 case 0x50:
12966                 case 0x60:
12967                 case 0x70:
12968                 case 0x80:
12969                 case 0x90:
12970                 case 0xa0:
12971                 case 0xb0:
12972                 case 0xc0:
12973                 case 0xd0:
12974                 case 0xe0:
12975                   goto op_semantics_113;
12976                   break;
12977                 case 0xf0:
12978                   goto op_semantics_114;
12979                   break;
12980               }
12981             break;
12982           case 0xe5:
12983               GETBYTE ();
12984               switch (op[2] & 0xf0)
12985               {
12986                 case 0x00:
12987                 case 0x10:
12988                 case 0x20:
12989                 case 0x30:
12990                 case 0x40:
12991                 case 0x50:
12992                 case 0x60:
12993                 case 0x70:
12994                 case 0x80:
12995                 case 0x90:
12996                 case 0xa0:
12997                 case 0xb0:
12998                 case 0xc0:
12999                 case 0xd0:
13000                 case 0xe0:
13001                   goto op_semantics_113;
13002                   break;
13003                 case 0xf0:
13004                   goto op_semantics_114;
13005                   break;
13006               }
13007             break;
13008           case 0xe6:
13009               GETBYTE ();
13010               switch (op[2] & 0xf0)
13011               {
13012                 case 0x00:
13013                 case 0x10:
13014                 case 0x20:
13015                 case 0x30:
13016                 case 0x40:
13017                 case 0x50:
13018                 case 0x60:
13019                 case 0x70:
13020                 case 0x80:
13021                 case 0x90:
13022                 case 0xa0:
13023                 case 0xb0:
13024                 case 0xc0:
13025                 case 0xd0:
13026                 case 0xe0:
13027                   goto op_semantics_113;
13028                   break;
13029                 case 0xf0:
13030                   goto op_semantics_114;
13031                   break;
13032               }
13033             break;
13034           case 0xe7:
13035               GETBYTE ();
13036               switch (op[2] & 0xf0)
13037               {
13038                 case 0x00:
13039                 case 0x10:
13040                 case 0x20:
13041                 case 0x30:
13042                 case 0x40:
13043                 case 0x50:
13044                 case 0x60:
13045                 case 0x70:
13046                 case 0x80:
13047                 case 0x90:
13048                 case 0xa0:
13049                 case 0xb0:
13050                 case 0xc0:
13051                 case 0xd0:
13052                 case 0xe0:
13053                   goto op_semantics_113;
13054                   break;
13055                 case 0xf0:
13056                   goto op_semantics_114;
13057                   break;
13058               }
13059             break;
13060           case 0xe8:
13061               GETBYTE ();
13062               switch (op[2] & 0xf0)
13063               {
13064                 case 0x00:
13065                 case 0x10:
13066                 case 0x20:
13067                 case 0x30:
13068                 case 0x40:
13069                 case 0x50:
13070                 case 0x60:
13071                 case 0x70:
13072                 case 0x80:
13073                 case 0x90:
13074                 case 0xa0:
13075                 case 0xb0:
13076                 case 0xc0:
13077                 case 0xd0:
13078                 case 0xe0:
13079                   goto op_semantics_113;
13080                   break;
13081                 case 0xf0:
13082                   goto op_semantics_114;
13083                   break;
13084               }
13085             break;
13086           case 0xe9:
13087               GETBYTE ();
13088               switch (op[2] & 0xf0)
13089               {
13090                 case 0x00:
13091                 case 0x10:
13092                 case 0x20:
13093                 case 0x30:
13094                 case 0x40:
13095                 case 0x50:
13096                 case 0x60:
13097                 case 0x70:
13098                 case 0x80:
13099                 case 0x90:
13100                 case 0xa0:
13101                 case 0xb0:
13102                 case 0xc0:
13103                 case 0xd0:
13104                 case 0xe0:
13105                   goto op_semantics_113;
13106                   break;
13107                 case 0xf0:
13108                   goto op_semantics_114;
13109                   break;
13110               }
13111             break;
13112           case 0xea:
13113               GETBYTE ();
13114               switch (op[2] & 0xf0)
13115               {
13116                 case 0x00:
13117                 case 0x10:
13118                 case 0x20:
13119                 case 0x30:
13120                 case 0x40:
13121                 case 0x50:
13122                 case 0x60:
13123                 case 0x70:
13124                 case 0x80:
13125                 case 0x90:
13126                 case 0xa0:
13127                 case 0xb0:
13128                 case 0xc0:
13129                 case 0xd0:
13130                 case 0xe0:
13131                   goto op_semantics_113;
13132                   break;
13133                 case 0xf0:
13134                   goto op_semantics_114;
13135                   break;
13136               }
13137             break;
13138           case 0xeb:
13139               GETBYTE ();
13140               switch (op[2] & 0xf0)
13141               {
13142                 case 0x00:
13143                 case 0x10:
13144                 case 0x20:
13145                 case 0x30:
13146                 case 0x40:
13147                 case 0x50:
13148                 case 0x60:
13149                 case 0x70:
13150                 case 0x80:
13151                 case 0x90:
13152                 case 0xa0:
13153                 case 0xb0:
13154                 case 0xc0:
13155                 case 0xd0:
13156                 case 0xe0:
13157                   goto op_semantics_113;
13158                   break;
13159                 case 0xf0:
13160                   goto op_semantics_114;
13161                   break;
13162               }
13163             break;
13164           case 0xec:
13165               GETBYTE ();
13166               switch (op[2] & 0xf0)
13167               {
13168                 case 0x00:
13169                 case 0x10:
13170                 case 0x20:
13171                 case 0x30:
13172                 case 0x40:
13173                 case 0x50:
13174                 case 0x60:
13175                 case 0x70:
13176                 case 0x80:
13177                 case 0x90:
13178                 case 0xa0:
13179                 case 0xb0:
13180                 case 0xc0:
13181                 case 0xd0:
13182                 case 0xe0:
13183                   goto op_semantics_113;
13184                   break;
13185                 case 0xf0:
13186                   goto op_semantics_114;
13187                   break;
13188               }
13189             break;
13190           case 0xed:
13191               GETBYTE ();
13192               switch (op[2] & 0xf0)
13193               {
13194                 case 0x00:
13195                 case 0x10:
13196                 case 0x20:
13197                 case 0x30:
13198                 case 0x40:
13199                 case 0x50:
13200                 case 0x60:
13201                 case 0x70:
13202                 case 0x80:
13203                 case 0x90:
13204                 case 0xa0:
13205                 case 0xb0:
13206                 case 0xc0:
13207                 case 0xd0:
13208                 case 0xe0:
13209                   goto op_semantics_113;
13210                   break;
13211                 case 0xf0:
13212                   goto op_semantics_114;
13213                   break;
13214               }
13215             break;
13216           case 0xee:
13217               GETBYTE ();
13218               switch (op[2] & 0xf0)
13219               {
13220                 case 0x00:
13221                 case 0x10:
13222                 case 0x20:
13223                 case 0x30:
13224                 case 0x40:
13225                 case 0x50:
13226                 case 0x60:
13227                 case 0x70:
13228                 case 0x80:
13229                 case 0x90:
13230                 case 0xa0:
13231                 case 0xb0:
13232                 case 0xc0:
13233                 case 0xd0:
13234                 case 0xe0:
13235                   goto op_semantics_113;
13236                   break;
13237                 case 0xf0:
13238                   goto op_semantics_114;
13239                   break;
13240               }
13241             break;
13242           case 0xef:
13243               GETBYTE ();
13244               switch (op[2] & 0xf0)
13245               {
13246                 case 0x00:
13247                 case 0x10:
13248                 case 0x20:
13249                 case 0x30:
13250                 case 0x40:
13251                 case 0x50:
13252                 case 0x60:
13253                 case 0x70:
13254                 case 0x80:
13255                 case 0x90:
13256                 case 0xa0:
13257                 case 0xb0:
13258                 case 0xc0:
13259                 case 0xd0:
13260                 case 0xe0:
13261                   goto op_semantics_113;
13262                   break;
13263                 case 0xf0:
13264                   goto op_semantics_114;
13265                   break;
13266               }
13267             break;
13268           case 0xf0:
13269               GETBYTE ();
13270               switch (op[2] & 0xf0)
13271               {
13272                 case 0x00:
13273                 case 0x10:
13274                 case 0x20:
13275                 case 0x30:
13276                 case 0x40:
13277                 case 0x50:
13278                 case 0x60:
13279                 case 0x70:
13280                 case 0x80:
13281                 case 0x90:
13282                 case 0xa0:
13283                 case 0xb0:
13284                 case 0xc0:
13285                 case 0xd0:
13286                 case 0xe0:
13287                   goto op_semantics_113;
13288                   break;
13289                 case 0xf0:
13290                   goto op_semantics_114;
13291                   break;
13292               }
13293             break;
13294           case 0xf1:
13295               GETBYTE ();
13296               switch (op[2] & 0xf0)
13297               {
13298                 case 0x00:
13299                 case 0x10:
13300                 case 0x20:
13301                 case 0x30:
13302                 case 0x40:
13303                 case 0x50:
13304                 case 0x60:
13305                 case 0x70:
13306                 case 0x80:
13307                 case 0x90:
13308                 case 0xa0:
13309                 case 0xb0:
13310                 case 0xc0:
13311                 case 0xd0:
13312                 case 0xe0:
13313                   goto op_semantics_113;
13314                   break;
13315                 case 0xf0:
13316                   goto op_semantics_114;
13317                   break;
13318               }
13319             break;
13320           case 0xf2:
13321               GETBYTE ();
13322               switch (op[2] & 0xf0)
13323               {
13324                 case 0x00:
13325                 case 0x10:
13326                 case 0x20:
13327                 case 0x30:
13328                 case 0x40:
13329                 case 0x50:
13330                 case 0x60:
13331                 case 0x70:
13332                 case 0x80:
13333                 case 0x90:
13334                 case 0xa0:
13335                 case 0xb0:
13336                 case 0xc0:
13337                 case 0xd0:
13338                 case 0xe0:
13339                   goto op_semantics_113;
13340                   break;
13341                 case 0xf0:
13342                   goto op_semantics_114;
13343                   break;
13344               }
13345             break;
13346           case 0xf3:
13347               GETBYTE ();
13348               switch (op[2] & 0xf0)
13349               {
13350                 case 0x00:
13351                 case 0x10:
13352                 case 0x20:
13353                 case 0x30:
13354                 case 0x40:
13355                 case 0x50:
13356                 case 0x60:
13357                 case 0x70:
13358                 case 0x80:
13359                 case 0x90:
13360                 case 0xa0:
13361                 case 0xb0:
13362                 case 0xc0:
13363                 case 0xd0:
13364                 case 0xe0:
13365                   goto op_semantics_113;
13366                   break;
13367                 case 0xf0:
13368                   goto op_semantics_114;
13369                   break;
13370               }
13371             break;
13372           case 0xf4:
13373               GETBYTE ();
13374               switch (op[2] & 0xf0)
13375               {
13376                 case 0x00:
13377                 case 0x10:
13378                 case 0x20:
13379                 case 0x30:
13380                 case 0x40:
13381                 case 0x50:
13382                 case 0x60:
13383                 case 0x70:
13384                 case 0x80:
13385                 case 0x90:
13386                 case 0xa0:
13387                 case 0xb0:
13388                 case 0xc0:
13389                 case 0xd0:
13390                 case 0xe0:
13391                   goto op_semantics_113;
13392                   break;
13393                 case 0xf0:
13394                   goto op_semantics_114;
13395                   break;
13396               }
13397             break;
13398           case 0xf5:
13399               GETBYTE ();
13400               switch (op[2] & 0xf0)
13401               {
13402                 case 0x00:
13403                 case 0x10:
13404                 case 0x20:
13405                 case 0x30:
13406                 case 0x40:
13407                 case 0x50:
13408                 case 0x60:
13409                 case 0x70:
13410                 case 0x80:
13411                 case 0x90:
13412                 case 0xa0:
13413                 case 0xb0:
13414                 case 0xc0:
13415                 case 0xd0:
13416                 case 0xe0:
13417                   goto op_semantics_113;
13418                   break;
13419                 case 0xf0:
13420                   goto op_semantics_114;
13421                   break;
13422               }
13423             break;
13424           case 0xf6:
13425               GETBYTE ();
13426               switch (op[2] & 0xf0)
13427               {
13428                 case 0x00:
13429                 case 0x10:
13430                 case 0x20:
13431                 case 0x30:
13432                 case 0x40:
13433                 case 0x50:
13434                 case 0x60:
13435                 case 0x70:
13436                 case 0x80:
13437                 case 0x90:
13438                 case 0xa0:
13439                 case 0xb0:
13440                 case 0xc0:
13441                 case 0xd0:
13442                 case 0xe0:
13443                   goto op_semantics_113;
13444                   break;
13445                 case 0xf0:
13446                   goto op_semantics_114;
13447                   break;
13448               }
13449             break;
13450           case 0xf7:
13451               GETBYTE ();
13452               switch (op[2] & 0xf0)
13453               {
13454                 case 0x00:
13455                 case 0x10:
13456                 case 0x20:
13457                 case 0x30:
13458                 case 0x40:
13459                 case 0x50:
13460                 case 0x60:
13461                 case 0x70:
13462                 case 0x80:
13463                 case 0x90:
13464                 case 0xa0:
13465                 case 0xb0:
13466                 case 0xc0:
13467                 case 0xd0:
13468                 case 0xe0:
13469                   goto op_semantics_113;
13470                   break;
13471                 case 0xf0:
13472                   goto op_semantics_114;
13473                   break;
13474               }
13475             break;
13476           case 0xf8:
13477               GETBYTE ();
13478               switch (op[2] & 0xf0)
13479               {
13480                 case 0x00:
13481                 case 0x10:
13482                 case 0x20:
13483                 case 0x30:
13484                 case 0x40:
13485                 case 0x50:
13486                 case 0x60:
13487                 case 0x70:
13488                 case 0x80:
13489                 case 0x90:
13490                 case 0xa0:
13491                 case 0xb0:
13492                 case 0xc0:
13493                 case 0xd0:
13494                 case 0xe0:
13495                   goto op_semantics_113;
13496                   break;
13497                 case 0xf0:
13498                   goto op_semantics_114;
13499                   break;
13500               }
13501             break;
13502           case 0xf9:
13503               GETBYTE ();
13504               switch (op[2] & 0xf0)
13505               {
13506                 case 0x00:
13507                 case 0x10:
13508                 case 0x20:
13509                 case 0x30:
13510                 case 0x40:
13511                 case 0x50:
13512                 case 0x60:
13513                 case 0x70:
13514                 case 0x80:
13515                 case 0x90:
13516                 case 0xa0:
13517                 case 0xb0:
13518                 case 0xc0:
13519                 case 0xd0:
13520                 case 0xe0:
13521                   goto op_semantics_113;
13522                   break;
13523                 case 0xf0:
13524                   goto op_semantics_114;
13525                   break;
13526               }
13527             break;
13528           case 0xfa:
13529               GETBYTE ();
13530               switch (op[2] & 0xf0)
13531               {
13532                 case 0x00:
13533                 case 0x10:
13534                 case 0x20:
13535                 case 0x30:
13536                 case 0x40:
13537                 case 0x50:
13538                 case 0x60:
13539                 case 0x70:
13540                 case 0x80:
13541                 case 0x90:
13542                 case 0xa0:
13543                 case 0xb0:
13544                 case 0xc0:
13545                 case 0xd0:
13546                 case 0xe0:
13547                   goto op_semantics_113;
13548                   break;
13549                 case 0xf0:
13550                   goto op_semantics_114;
13551                   break;
13552               }
13553             break;
13554           case 0xfb:
13555               GETBYTE ();
13556               switch (op[2] & 0xf0)
13557               {
13558                 case 0x00:
13559                 case 0x10:
13560                 case 0x20:
13561                 case 0x30:
13562                 case 0x40:
13563                 case 0x50:
13564                 case 0x60:
13565                 case 0x70:
13566                 case 0x80:
13567                 case 0x90:
13568                 case 0xa0:
13569                 case 0xb0:
13570                 case 0xc0:
13571                 case 0xd0:
13572                 case 0xe0:
13573                   goto op_semantics_113;
13574                   break;
13575                 case 0xf0:
13576                   goto op_semantics_114;
13577                   break;
13578               }
13579             break;
13580           case 0xfc:
13581               GETBYTE ();
13582               switch (op[2] & 0xf0)
13583               {
13584                 case 0x00:
13585                 case 0x10:
13586                 case 0x20:
13587                 case 0x30:
13588                 case 0x40:
13589                 case 0x50:
13590                 case 0x60:
13591                 case 0x70:
13592                 case 0x80:
13593                 case 0x90:
13594                 case 0xa0:
13595                 case 0xb0:
13596                 case 0xc0:
13597                 case 0xd0:
13598                 case 0xe0:
13599                   goto op_semantics_113;
13600                   break;
13601                 case 0xf0:
13602                   goto op_semantics_114;
13603                   break;
13604               }
13605             break;
13606           case 0xfd:
13607               GETBYTE ();
13608               switch (op[2] & 0xf0)
13609               {
13610                 case 0x00:
13611                 case 0x10:
13612                 case 0x20:
13613                 case 0x30:
13614                 case 0x40:
13615                 case 0x50:
13616                 case 0x60:
13617                 case 0x70:
13618                 case 0x80:
13619                 case 0x90:
13620                 case 0xa0:
13621                 case 0xb0:
13622                 case 0xc0:
13623                 case 0xd0:
13624                 case 0xe0:
13625                   goto op_semantics_113;
13626                   break;
13627                 case 0xf0:
13628                   goto op_semantics_114;
13629                   break;
13630               }
13631             break;
13632           case 0xfe:
13633               GETBYTE ();
13634               switch (op[2] & 0xf0)
13635               {
13636                 case 0x00:
13637                 case 0x10:
13638                 case 0x20:
13639                 case 0x30:
13640                 case 0x40:
13641                 case 0x50:
13642                 case 0x60:
13643                 case 0x70:
13644                 case 0x80:
13645                 case 0x90:
13646                 case 0xa0:
13647                 case 0xb0:
13648                 case 0xc0:
13649                 case 0xd0:
13650                 case 0xe0:
13651                   goto op_semantics_113;
13652                   break;
13653                 case 0xf0:
13654                   goto op_semantics_114;
13655                   break;
13656               }
13657             break;
13658           case 0xff:
13659               GETBYTE ();
13660               switch (op[2] & 0xf0)
13661               {
13662                 case 0x00:
13663                 case 0x10:
13664                 case 0x20:
13665                 case 0x30:
13666                 case 0x40:
13667                 case 0x50:
13668                 case 0x60:
13669                 case 0x70:
13670                 case 0x80:
13671                 case 0x90:
13672                 case 0xa0:
13673                 case 0xb0:
13674                 case 0xc0:
13675                 case 0xd0:
13676                 case 0xe0:
13677                   goto op_semantics_113;
13678                   break;
13679                 case 0xf0:
13680                   goto op_semantics_114;
13681                   break;
13682               }
13683             break;
13684           default: UNSUPPORTED(); break;
13685         }
13686       break;
13687     case 0xfe:
13688         GETBYTE ();
13689         switch (op[1] & 0xff)
13690         {
13691           case 0x00:
13692               GETBYTE ();
13693               switch (op[2] & 0x00)
13694               {
13695                 case 0x00:
13696                   op_semantics_115:
13697                     {
13698                       /** 1111 1110 00sz isrc bsrc rdst mov%s   %0, [%1, %2] */
13699 #line 342 "rx-decode.opc"
13700                       int sz AU = (op[1] >> 4) & 0x03;
13701 #line 342 "rx-decode.opc"
13702                       int isrc AU = op[1] & 0x0f;
13703 #line 342 "rx-decode.opc"
13704                       int bsrc AU = (op[2] >> 4) & 0x0f;
13705 #line 342 "rx-decode.opc"
13706                       int rdst AU = op[2] & 0x0f;
13707                       if (trace)
13708                         {
13709                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13710                                  "/** 1111 1110 00sz isrc bsrc rdst     mov%s   %0, [%1, %2] */",
13711                                  op[0], op[1], op[2]);
13712                           printf ("  sz = 0x%x,", sz);
13713                           printf ("  isrc = 0x%x,", isrc);
13714                           printf ("  bsrc = 0x%x,", bsrc);
13715                           printf ("  rdst = 0x%x\n", rdst);
13716                         }
13717                       SYNTAX("mov%s     %0, [%1, %2]");
13718 #line 342 "rx-decode.opc"
13719                       ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13720
13721                     }
13722                   break;
13723               }
13724             break;
13725           case 0x01:
13726               GETBYTE ();
13727               switch (op[2] & 0x00)
13728               {
13729                 case 0x00:
13730                   goto op_semantics_115;
13731                   break;
13732               }
13733             break;
13734           case 0x02:
13735               GETBYTE ();
13736               switch (op[2] & 0x00)
13737               {
13738                 case 0x00:
13739                   goto op_semantics_115;
13740                   break;
13741               }
13742             break;
13743           case 0x03:
13744               GETBYTE ();
13745               switch (op[2] & 0x00)
13746               {
13747                 case 0x00:
13748                   goto op_semantics_115;
13749                   break;
13750               }
13751             break;
13752           case 0x04:
13753               GETBYTE ();
13754               switch (op[2] & 0x00)
13755               {
13756                 case 0x00:
13757                   goto op_semantics_115;
13758                   break;
13759               }
13760             break;
13761           case 0x05:
13762               GETBYTE ();
13763               switch (op[2] & 0x00)
13764               {
13765                 case 0x00:
13766                   goto op_semantics_115;
13767                   break;
13768               }
13769             break;
13770           case 0x06:
13771               GETBYTE ();
13772               switch (op[2] & 0x00)
13773               {
13774                 case 0x00:
13775                   goto op_semantics_115;
13776                   break;
13777               }
13778             break;
13779           case 0x07:
13780               GETBYTE ();
13781               switch (op[2] & 0x00)
13782               {
13783                 case 0x00:
13784                   goto op_semantics_115;
13785                   break;
13786               }
13787             break;
13788           case 0x08:
13789               GETBYTE ();
13790               switch (op[2] & 0x00)
13791               {
13792                 case 0x00:
13793                   goto op_semantics_115;
13794                   break;
13795               }
13796             break;
13797           case 0x09:
13798               GETBYTE ();
13799               switch (op[2] & 0x00)
13800               {
13801                 case 0x00:
13802                   goto op_semantics_115;
13803                   break;
13804               }
13805             break;
13806           case 0x0a:
13807               GETBYTE ();
13808               switch (op[2] & 0x00)
13809               {
13810                 case 0x00:
13811                   goto op_semantics_115;
13812                   break;
13813               }
13814             break;
13815           case 0x0b:
13816               GETBYTE ();
13817               switch (op[2] & 0x00)
13818               {
13819                 case 0x00:
13820                   goto op_semantics_115;
13821                   break;
13822               }
13823             break;
13824           case 0x0c:
13825               GETBYTE ();
13826               switch (op[2] & 0x00)
13827               {
13828                 case 0x00:
13829                   goto op_semantics_115;
13830                   break;
13831               }
13832             break;
13833           case 0x0d:
13834               GETBYTE ();
13835               switch (op[2] & 0x00)
13836               {
13837                 case 0x00:
13838                   goto op_semantics_115;
13839                   break;
13840               }
13841             break;
13842           case 0x0e:
13843               GETBYTE ();
13844               switch (op[2] & 0x00)
13845               {
13846                 case 0x00:
13847                   goto op_semantics_115;
13848                   break;
13849               }
13850             break;
13851           case 0x0f:
13852               GETBYTE ();
13853               switch (op[2] & 0x00)
13854               {
13855                 case 0x00:
13856                   goto op_semantics_115;
13857                   break;
13858               }
13859             break;
13860           case 0x10:
13861               GETBYTE ();
13862               switch (op[2] & 0x00)
13863               {
13864                 case 0x00:
13865                   goto op_semantics_115;
13866                   break;
13867               }
13868             break;
13869           case 0x11:
13870               GETBYTE ();
13871               switch (op[2] & 0x00)
13872               {
13873                 case 0x00:
13874                   goto op_semantics_115;
13875                   break;
13876               }
13877             break;
13878           case 0x12:
13879               GETBYTE ();
13880               switch (op[2] & 0x00)
13881               {
13882                 case 0x00:
13883                   goto op_semantics_115;
13884                   break;
13885               }
13886             break;
13887           case 0x13:
13888               GETBYTE ();
13889               switch (op[2] & 0x00)
13890               {
13891                 case 0x00:
13892                   goto op_semantics_115;
13893                   break;
13894               }
13895             break;
13896           case 0x14:
13897               GETBYTE ();
13898               switch (op[2] & 0x00)
13899               {
13900                 case 0x00:
13901                   goto op_semantics_115;
13902                   break;
13903               }
13904             break;
13905           case 0x15:
13906               GETBYTE ();
13907               switch (op[2] & 0x00)
13908               {
13909                 case 0x00:
13910                   goto op_semantics_115;
13911                   break;
13912               }
13913             break;
13914           case 0x16:
13915               GETBYTE ();
13916               switch (op[2] & 0x00)
13917               {
13918                 case 0x00:
13919                   goto op_semantics_115;
13920                   break;
13921               }
13922             break;
13923           case 0x17:
13924               GETBYTE ();
13925               switch (op[2] & 0x00)
13926               {
13927                 case 0x00:
13928                   goto op_semantics_115;
13929                   break;
13930               }
13931             break;
13932           case 0x18:
13933               GETBYTE ();
13934               switch (op[2] & 0x00)
13935               {
13936                 case 0x00:
13937                   goto op_semantics_115;
13938                   break;
13939               }
13940             break;
13941           case 0x19:
13942               GETBYTE ();
13943               switch (op[2] & 0x00)
13944               {
13945                 case 0x00:
13946                   goto op_semantics_115;
13947                   break;
13948               }
13949             break;
13950           case 0x1a:
13951               GETBYTE ();
13952               switch (op[2] & 0x00)
13953               {
13954                 case 0x00:
13955                   goto op_semantics_115;
13956                   break;
13957               }
13958             break;
13959           case 0x1b:
13960               GETBYTE ();
13961               switch (op[2] & 0x00)
13962               {
13963                 case 0x00:
13964                   goto op_semantics_115;
13965                   break;
13966               }
13967             break;
13968           case 0x1c:
13969               GETBYTE ();
13970               switch (op[2] & 0x00)
13971               {
13972                 case 0x00:
13973                   goto op_semantics_115;
13974                   break;
13975               }
13976             break;
13977           case 0x1d:
13978               GETBYTE ();
13979               switch (op[2] & 0x00)
13980               {
13981                 case 0x00:
13982                   goto op_semantics_115;
13983                   break;
13984               }
13985             break;
13986           case 0x1e:
13987               GETBYTE ();
13988               switch (op[2] & 0x00)
13989               {
13990                 case 0x00:
13991                   goto op_semantics_115;
13992                   break;
13993               }
13994             break;
13995           case 0x1f:
13996               GETBYTE ();
13997               switch (op[2] & 0x00)
13998               {
13999                 case 0x00:
14000                   goto op_semantics_115;
14001                   break;
14002               }
14003             break;
14004           case 0x20:
14005               GETBYTE ();
14006               switch (op[2] & 0x00)
14007               {
14008                 case 0x00:
14009                   goto op_semantics_115;
14010                   break;
14011               }
14012             break;
14013           case 0x21:
14014               GETBYTE ();
14015               switch (op[2] & 0x00)
14016               {
14017                 case 0x00:
14018                   goto op_semantics_115;
14019                   break;
14020               }
14021             break;
14022           case 0x22:
14023               GETBYTE ();
14024               switch (op[2] & 0x00)
14025               {
14026                 case 0x00:
14027                   goto op_semantics_115;
14028                   break;
14029               }
14030             break;
14031           case 0x23:
14032               GETBYTE ();
14033               switch (op[2] & 0x00)
14034               {
14035                 case 0x00:
14036                   goto op_semantics_115;
14037                   break;
14038               }
14039             break;
14040           case 0x24:
14041               GETBYTE ();
14042               switch (op[2] & 0x00)
14043               {
14044                 case 0x00:
14045                   goto op_semantics_115;
14046                   break;
14047               }
14048             break;
14049           case 0x25:
14050               GETBYTE ();
14051               switch (op[2] & 0x00)
14052               {
14053                 case 0x00:
14054                   goto op_semantics_115;
14055                   break;
14056               }
14057             break;
14058           case 0x26:
14059               GETBYTE ();
14060               switch (op[2] & 0x00)
14061               {
14062                 case 0x00:
14063                   goto op_semantics_115;
14064                   break;
14065               }
14066             break;
14067           case 0x27:
14068               GETBYTE ();
14069               switch (op[2] & 0x00)
14070               {
14071                 case 0x00:
14072                   goto op_semantics_115;
14073                   break;
14074               }
14075             break;
14076           case 0x28:
14077               GETBYTE ();
14078               switch (op[2] & 0x00)
14079               {
14080                 case 0x00:
14081                   goto op_semantics_115;
14082                   break;
14083               }
14084             break;
14085           case 0x29:
14086               GETBYTE ();
14087               switch (op[2] & 0x00)
14088               {
14089                 case 0x00:
14090                   goto op_semantics_115;
14091                   break;
14092               }
14093             break;
14094           case 0x2a:
14095               GETBYTE ();
14096               switch (op[2] & 0x00)
14097               {
14098                 case 0x00:
14099                   goto op_semantics_115;
14100                   break;
14101               }
14102             break;
14103           case 0x2b:
14104               GETBYTE ();
14105               switch (op[2] & 0x00)
14106               {
14107                 case 0x00:
14108                   goto op_semantics_115;
14109                   break;
14110               }
14111             break;
14112           case 0x2c:
14113               GETBYTE ();
14114               switch (op[2] & 0x00)
14115               {
14116                 case 0x00:
14117                   goto op_semantics_115;
14118                   break;
14119               }
14120             break;
14121           case 0x2d:
14122               GETBYTE ();
14123               switch (op[2] & 0x00)
14124               {
14125                 case 0x00:
14126                   goto op_semantics_115;
14127                   break;
14128               }
14129             break;
14130           case 0x2e:
14131               GETBYTE ();
14132               switch (op[2] & 0x00)
14133               {
14134                 case 0x00:
14135                   goto op_semantics_115;
14136                   break;
14137               }
14138             break;
14139           case 0x2f:
14140               GETBYTE ();
14141               switch (op[2] & 0x00)
14142               {
14143                 case 0x00:
14144                   goto op_semantics_115;
14145                   break;
14146               }
14147             break;
14148           case 0x40:
14149               GETBYTE ();
14150               switch (op[2] & 0x00)
14151               {
14152                 case 0x00:
14153                   op_semantics_116:
14154                     {
14155                       /** 1111 1110 01sz isrc bsrc rdst mov%s   [%1, %2], %0 */
14156 #line 339 "rx-decode.opc"
14157                       int sz AU = (op[1] >> 4) & 0x03;
14158 #line 339 "rx-decode.opc"
14159                       int isrc AU = op[1] & 0x0f;
14160 #line 339 "rx-decode.opc"
14161                       int bsrc AU = (op[2] >> 4) & 0x0f;
14162 #line 339 "rx-decode.opc"
14163                       int rdst AU = op[2] & 0x0f;
14164                       if (trace)
14165                         {
14166                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14167                                  "/** 1111 1110 01sz isrc bsrc rdst     mov%s   [%1, %2], %0 */",
14168                                  op[0], op[1], op[2]);
14169                           printf ("  sz = 0x%x,", sz);
14170                           printf ("  isrc = 0x%x,", isrc);
14171                           printf ("  bsrc = 0x%x,", bsrc);
14172                           printf ("  rdst = 0x%x\n", rdst);
14173                         }
14174                       SYNTAX("mov%s     [%1, %2], %0");
14175 #line 339 "rx-decode.opc"
14176                       ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
14177
14178                     }
14179                   break;
14180               }
14181             break;
14182           case 0x41:
14183               GETBYTE ();
14184               switch (op[2] & 0x00)
14185               {
14186                 case 0x00:
14187                   goto op_semantics_116;
14188                   break;
14189               }
14190             break;
14191           case 0x42:
14192               GETBYTE ();
14193               switch (op[2] & 0x00)
14194               {
14195                 case 0x00:
14196                   goto op_semantics_116;
14197                   break;
14198               }
14199             break;
14200           case 0x43:
14201               GETBYTE ();
14202               switch (op[2] & 0x00)
14203               {
14204                 case 0x00:
14205                   goto op_semantics_116;
14206                   break;
14207               }
14208             break;
14209           case 0x44:
14210               GETBYTE ();
14211               switch (op[2] & 0x00)
14212               {
14213                 case 0x00:
14214                   goto op_semantics_116;
14215                   break;
14216               }
14217             break;
14218           case 0x45:
14219               GETBYTE ();
14220               switch (op[2] & 0x00)
14221               {
14222                 case 0x00:
14223                   goto op_semantics_116;
14224                   break;
14225               }
14226             break;
14227           case 0x46:
14228               GETBYTE ();
14229               switch (op[2] & 0x00)
14230               {
14231                 case 0x00:
14232                   goto op_semantics_116;
14233                   break;
14234               }
14235             break;
14236           case 0x47:
14237               GETBYTE ();
14238               switch (op[2] & 0x00)
14239               {
14240                 case 0x00:
14241                   goto op_semantics_116;
14242                   break;
14243               }
14244             break;
14245           case 0x48:
14246               GETBYTE ();
14247               switch (op[2] & 0x00)
14248               {
14249                 case 0x00:
14250                   goto op_semantics_116;
14251                   break;
14252               }
14253             break;
14254           case 0x49:
14255               GETBYTE ();
14256               switch (op[2] & 0x00)
14257               {
14258                 case 0x00:
14259                   goto op_semantics_116;
14260                   break;
14261               }
14262             break;
14263           case 0x4a:
14264               GETBYTE ();
14265               switch (op[2] & 0x00)
14266               {
14267                 case 0x00:
14268                   goto op_semantics_116;
14269                   break;
14270               }
14271             break;
14272           case 0x4b:
14273               GETBYTE ();
14274               switch (op[2] & 0x00)
14275               {
14276                 case 0x00:
14277                   goto op_semantics_116;
14278                   break;
14279               }
14280             break;
14281           case 0x4c:
14282               GETBYTE ();
14283               switch (op[2] & 0x00)
14284               {
14285                 case 0x00:
14286                   goto op_semantics_116;
14287                   break;
14288               }
14289             break;
14290           case 0x4d:
14291               GETBYTE ();
14292               switch (op[2] & 0x00)
14293               {
14294                 case 0x00:
14295                   goto op_semantics_116;
14296                   break;
14297               }
14298             break;
14299           case 0x4e:
14300               GETBYTE ();
14301               switch (op[2] & 0x00)
14302               {
14303                 case 0x00:
14304                   goto op_semantics_116;
14305                   break;
14306               }
14307             break;
14308           case 0x4f:
14309               GETBYTE ();
14310               switch (op[2] & 0x00)
14311               {
14312                 case 0x00:
14313                   goto op_semantics_116;
14314                   break;
14315               }
14316             break;
14317           case 0x50:
14318               GETBYTE ();
14319               switch (op[2] & 0x00)
14320               {
14321                 case 0x00:
14322                   goto op_semantics_116;
14323                   break;
14324               }
14325             break;
14326           case 0x51:
14327               GETBYTE ();
14328               switch (op[2] & 0x00)
14329               {
14330                 case 0x00:
14331                   goto op_semantics_116;
14332                   break;
14333               }
14334             break;
14335           case 0x52:
14336               GETBYTE ();
14337               switch (op[2] & 0x00)
14338               {
14339                 case 0x00:
14340                   goto op_semantics_116;
14341                   break;
14342               }
14343             break;
14344           case 0x53:
14345               GETBYTE ();
14346               switch (op[2] & 0x00)
14347               {
14348                 case 0x00:
14349                   goto op_semantics_116;
14350                   break;
14351               }
14352             break;
14353           case 0x54:
14354               GETBYTE ();
14355               switch (op[2] & 0x00)
14356               {
14357                 case 0x00:
14358                   goto op_semantics_116;
14359                   break;
14360               }
14361             break;
14362           case 0x55:
14363               GETBYTE ();
14364               switch (op[2] & 0x00)
14365               {
14366                 case 0x00:
14367                   goto op_semantics_116;
14368                   break;
14369               }
14370             break;
14371           case 0x56:
14372               GETBYTE ();
14373               switch (op[2] & 0x00)
14374               {
14375                 case 0x00:
14376                   goto op_semantics_116;
14377                   break;
14378               }
14379             break;
14380           case 0x57:
14381               GETBYTE ();
14382               switch (op[2] & 0x00)
14383               {
14384                 case 0x00:
14385                   goto op_semantics_116;
14386                   break;
14387               }
14388             break;
14389           case 0x58:
14390               GETBYTE ();
14391               switch (op[2] & 0x00)
14392               {
14393                 case 0x00:
14394                   goto op_semantics_116;
14395                   break;
14396               }
14397             break;
14398           case 0x59:
14399               GETBYTE ();
14400               switch (op[2] & 0x00)
14401               {
14402                 case 0x00:
14403                   goto op_semantics_116;
14404                   break;
14405               }
14406             break;
14407           case 0x5a:
14408               GETBYTE ();
14409               switch (op[2] & 0x00)
14410               {
14411                 case 0x00:
14412                   goto op_semantics_116;
14413                   break;
14414               }
14415             break;
14416           case 0x5b:
14417               GETBYTE ();
14418               switch (op[2] & 0x00)
14419               {
14420                 case 0x00:
14421                   goto op_semantics_116;
14422                   break;
14423               }
14424             break;
14425           case 0x5c:
14426               GETBYTE ();
14427               switch (op[2] & 0x00)
14428               {
14429                 case 0x00:
14430                   goto op_semantics_116;
14431                   break;
14432               }
14433             break;
14434           case 0x5d:
14435               GETBYTE ();
14436               switch (op[2] & 0x00)
14437               {
14438                 case 0x00:
14439                   goto op_semantics_116;
14440                   break;
14441               }
14442             break;
14443           case 0x5e:
14444               GETBYTE ();
14445               switch (op[2] & 0x00)
14446               {
14447                 case 0x00:
14448                   goto op_semantics_116;
14449                   break;
14450               }
14451             break;
14452           case 0x5f:
14453               GETBYTE ();
14454               switch (op[2] & 0x00)
14455               {
14456                 case 0x00:
14457                   goto op_semantics_116;
14458                   break;
14459               }
14460             break;
14461           case 0x60:
14462               GETBYTE ();
14463               switch (op[2] & 0x00)
14464               {
14465                 case 0x00:
14466                   goto op_semantics_116;
14467                   break;
14468               }
14469             break;
14470           case 0x61:
14471               GETBYTE ();
14472               switch (op[2] & 0x00)
14473               {
14474                 case 0x00:
14475                   goto op_semantics_116;
14476                   break;
14477               }
14478             break;
14479           case 0x62:
14480               GETBYTE ();
14481               switch (op[2] & 0x00)
14482               {
14483                 case 0x00:
14484                   goto op_semantics_116;
14485                   break;
14486               }
14487             break;
14488           case 0x63:
14489               GETBYTE ();
14490               switch (op[2] & 0x00)
14491               {
14492                 case 0x00:
14493                   goto op_semantics_116;
14494                   break;
14495               }
14496             break;
14497           case 0x64:
14498               GETBYTE ();
14499               switch (op[2] & 0x00)
14500               {
14501                 case 0x00:
14502                   goto op_semantics_116;
14503                   break;
14504               }
14505             break;
14506           case 0x65:
14507               GETBYTE ();
14508               switch (op[2] & 0x00)
14509               {
14510                 case 0x00:
14511                   goto op_semantics_116;
14512                   break;
14513               }
14514             break;
14515           case 0x66:
14516               GETBYTE ();
14517               switch (op[2] & 0x00)
14518               {
14519                 case 0x00:
14520                   goto op_semantics_116;
14521                   break;
14522               }
14523             break;
14524           case 0x67:
14525               GETBYTE ();
14526               switch (op[2] & 0x00)
14527               {
14528                 case 0x00:
14529                   goto op_semantics_116;
14530                   break;
14531               }
14532             break;
14533           case 0x68:
14534               GETBYTE ();
14535               switch (op[2] & 0x00)
14536               {
14537                 case 0x00:
14538                   goto op_semantics_116;
14539                   break;
14540               }
14541             break;
14542           case 0x69:
14543               GETBYTE ();
14544               switch (op[2] & 0x00)
14545               {
14546                 case 0x00:
14547                   goto op_semantics_116;
14548                   break;
14549               }
14550             break;
14551           case 0x6a:
14552               GETBYTE ();
14553               switch (op[2] & 0x00)
14554               {
14555                 case 0x00:
14556                   goto op_semantics_116;
14557                   break;
14558               }
14559             break;
14560           case 0x6b:
14561               GETBYTE ();
14562               switch (op[2] & 0x00)
14563               {
14564                 case 0x00:
14565                   goto op_semantics_116;
14566                   break;
14567               }
14568             break;
14569           case 0x6c:
14570               GETBYTE ();
14571               switch (op[2] & 0x00)
14572               {
14573                 case 0x00:
14574                   goto op_semantics_116;
14575                   break;
14576               }
14577             break;
14578           case 0x6d:
14579               GETBYTE ();
14580               switch (op[2] & 0x00)
14581               {
14582                 case 0x00:
14583                   goto op_semantics_116;
14584                   break;
14585               }
14586             break;
14587           case 0x6e:
14588               GETBYTE ();
14589               switch (op[2] & 0x00)
14590               {
14591                 case 0x00:
14592                   goto op_semantics_116;
14593                   break;
14594               }
14595             break;
14596           case 0x6f:
14597               GETBYTE ();
14598               switch (op[2] & 0x00)
14599               {
14600                 case 0x00:
14601                   goto op_semantics_116;
14602                   break;
14603               }
14604             break;
14605           case 0xc0:
14606               GETBYTE ();
14607               switch (op[2] & 0x00)
14608               {
14609                 case 0x00:
14610                   op_semantics_117:
14611                     {
14612                       /** 1111 1110 11sz isrc bsrc rdst movu%s  [%1, %2], %0 */
14613 #line 345 "rx-decode.opc"
14614                       int sz AU = (op[1] >> 4) & 0x03;
14615 #line 345 "rx-decode.opc"
14616                       int isrc AU = op[1] & 0x0f;
14617 #line 345 "rx-decode.opc"
14618                       int bsrc AU = (op[2] >> 4) & 0x0f;
14619 #line 345 "rx-decode.opc"
14620                       int rdst AU = op[2] & 0x0f;
14621                       if (trace)
14622                         {
14623                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14624                                  "/** 1111 1110 11sz isrc bsrc rdst     movu%s  [%1, %2], %0 */",
14625                                  op[0], op[1], op[2]);
14626                           printf ("  sz = 0x%x,", sz);
14627                           printf ("  isrc = 0x%x,", isrc);
14628                           printf ("  bsrc = 0x%x,", bsrc);
14629                           printf ("  rdst = 0x%x\n", rdst);
14630                         }
14631                       SYNTAX("movu%s    [%1, %2], %0");
14632 #line 345 "rx-decode.opc"
14633                       ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
14634
14635                     }
14636                   break;
14637               }
14638             break;
14639           case 0xc1:
14640               GETBYTE ();
14641               switch (op[2] & 0x00)
14642               {
14643                 case 0x00:
14644                   goto op_semantics_117;
14645                   break;
14646               }
14647             break;
14648           case 0xc2:
14649               GETBYTE ();
14650               switch (op[2] & 0x00)
14651               {
14652                 case 0x00:
14653                   goto op_semantics_117;
14654                   break;
14655               }
14656             break;
14657           case 0xc3:
14658               GETBYTE ();
14659               switch (op[2] & 0x00)
14660               {
14661                 case 0x00:
14662                   goto op_semantics_117;
14663                   break;
14664               }
14665             break;
14666           case 0xc4:
14667               GETBYTE ();
14668               switch (op[2] & 0x00)
14669               {
14670                 case 0x00:
14671                   goto op_semantics_117;
14672                   break;
14673               }
14674             break;
14675           case 0xc5:
14676               GETBYTE ();
14677               switch (op[2] & 0x00)
14678               {
14679                 case 0x00:
14680                   goto op_semantics_117;
14681                   break;
14682               }
14683             break;
14684           case 0xc6:
14685               GETBYTE ();
14686               switch (op[2] & 0x00)
14687               {
14688                 case 0x00:
14689                   goto op_semantics_117;
14690                   break;
14691               }
14692             break;
14693           case 0xc7:
14694               GETBYTE ();
14695               switch (op[2] & 0x00)
14696               {
14697                 case 0x00:
14698                   goto op_semantics_117;
14699                   break;
14700               }
14701             break;
14702           case 0xc8:
14703               GETBYTE ();
14704               switch (op[2] & 0x00)
14705               {
14706                 case 0x00:
14707                   goto op_semantics_117;
14708                   break;
14709               }
14710             break;
14711           case 0xc9:
14712               GETBYTE ();
14713               switch (op[2] & 0x00)
14714               {
14715                 case 0x00:
14716                   goto op_semantics_117;
14717                   break;
14718               }
14719             break;
14720           case 0xca:
14721               GETBYTE ();
14722               switch (op[2] & 0x00)
14723               {
14724                 case 0x00:
14725                   goto op_semantics_117;
14726                   break;
14727               }
14728             break;
14729           case 0xcb:
14730               GETBYTE ();
14731               switch (op[2] & 0x00)
14732               {
14733                 case 0x00:
14734                   goto op_semantics_117;
14735                   break;
14736               }
14737             break;
14738           case 0xcc:
14739               GETBYTE ();
14740               switch (op[2] & 0x00)
14741               {
14742                 case 0x00:
14743                   goto op_semantics_117;
14744                   break;
14745               }
14746             break;
14747           case 0xcd:
14748               GETBYTE ();
14749               switch (op[2] & 0x00)
14750               {
14751                 case 0x00:
14752                   goto op_semantics_117;
14753                   break;
14754               }
14755             break;
14756           case 0xce:
14757               GETBYTE ();
14758               switch (op[2] & 0x00)
14759               {
14760                 case 0x00:
14761                   goto op_semantics_117;
14762                   break;
14763               }
14764             break;
14765           case 0xcf:
14766               GETBYTE ();
14767               switch (op[2] & 0x00)
14768               {
14769                 case 0x00:
14770                   goto op_semantics_117;
14771                   break;
14772               }
14773             break;
14774           case 0xd0:
14775               GETBYTE ();
14776               switch (op[2] & 0x00)
14777               {
14778                 case 0x00:
14779                   goto op_semantics_117;
14780                   break;
14781               }
14782             break;
14783           case 0xd1:
14784               GETBYTE ();
14785               switch (op[2] & 0x00)
14786               {
14787                 case 0x00:
14788                   goto op_semantics_117;
14789                   break;
14790               }
14791             break;
14792           case 0xd2:
14793               GETBYTE ();
14794               switch (op[2] & 0x00)
14795               {
14796                 case 0x00:
14797                   goto op_semantics_117;
14798                   break;
14799               }
14800             break;
14801           case 0xd3:
14802               GETBYTE ();
14803               switch (op[2] & 0x00)
14804               {
14805                 case 0x00:
14806                   goto op_semantics_117;
14807                   break;
14808               }
14809             break;
14810           case 0xd4:
14811               GETBYTE ();
14812               switch (op[2] & 0x00)
14813               {
14814                 case 0x00:
14815                   goto op_semantics_117;
14816                   break;
14817               }
14818             break;
14819           case 0xd5:
14820               GETBYTE ();
14821               switch (op[2] & 0x00)
14822               {
14823                 case 0x00:
14824                   goto op_semantics_117;
14825                   break;
14826               }
14827             break;
14828           case 0xd6:
14829               GETBYTE ();
14830               switch (op[2] & 0x00)
14831               {
14832                 case 0x00:
14833                   goto op_semantics_117;
14834                   break;
14835               }
14836             break;
14837           case 0xd7:
14838               GETBYTE ();
14839               switch (op[2] & 0x00)
14840               {
14841                 case 0x00:
14842                   goto op_semantics_117;
14843                   break;
14844               }
14845             break;
14846           case 0xd8:
14847               GETBYTE ();
14848               switch (op[2] & 0x00)
14849               {
14850                 case 0x00:
14851                   goto op_semantics_117;
14852                   break;
14853               }
14854             break;
14855           case 0xd9:
14856               GETBYTE ();
14857               switch (op[2] & 0x00)
14858               {
14859                 case 0x00:
14860                   goto op_semantics_117;
14861                   break;
14862               }
14863             break;
14864           case 0xda:
14865               GETBYTE ();
14866               switch (op[2] & 0x00)
14867               {
14868                 case 0x00:
14869                   goto op_semantics_117;
14870                   break;
14871               }
14872             break;
14873           case 0xdb:
14874               GETBYTE ();
14875               switch (op[2] & 0x00)
14876               {
14877                 case 0x00:
14878                   goto op_semantics_117;
14879                   break;
14880               }
14881             break;
14882           case 0xdc:
14883               GETBYTE ();
14884               switch (op[2] & 0x00)
14885               {
14886                 case 0x00:
14887                   goto op_semantics_117;
14888                   break;
14889               }
14890             break;
14891           case 0xdd:
14892               GETBYTE ();
14893               switch (op[2] & 0x00)
14894               {
14895                 case 0x00:
14896                   goto op_semantics_117;
14897                   break;
14898               }
14899             break;
14900           case 0xde:
14901               GETBYTE ();
14902               switch (op[2] & 0x00)
14903               {
14904                 case 0x00:
14905                   goto op_semantics_117;
14906                   break;
14907               }
14908             break;
14909           case 0xdf:
14910               GETBYTE ();
14911               switch (op[2] & 0x00)
14912               {
14913                 case 0x00:
14914                   goto op_semantics_117;
14915                   break;
14916               }
14917             break;
14918           case 0xe0:
14919               GETBYTE ();
14920               switch (op[2] & 0x00)
14921               {
14922                 case 0x00:
14923                   goto op_semantics_117;
14924                   break;
14925               }
14926             break;
14927           case 0xe1:
14928               GETBYTE ();
14929               switch (op[2] & 0x00)
14930               {
14931                 case 0x00:
14932                   goto op_semantics_117;
14933                   break;
14934               }
14935             break;
14936           case 0xe2:
14937               GETBYTE ();
14938               switch (op[2] & 0x00)
14939               {
14940                 case 0x00:
14941                   goto op_semantics_117;
14942                   break;
14943               }
14944             break;
14945           case 0xe3:
14946               GETBYTE ();
14947               switch (op[2] & 0x00)
14948               {
14949                 case 0x00:
14950                   goto op_semantics_117;
14951                   break;
14952               }
14953             break;
14954           case 0xe4:
14955               GETBYTE ();
14956               switch (op[2] & 0x00)
14957               {
14958                 case 0x00:
14959                   goto op_semantics_117;
14960                   break;
14961               }
14962             break;
14963           case 0xe5:
14964               GETBYTE ();
14965               switch (op[2] & 0x00)
14966               {
14967                 case 0x00:
14968                   goto op_semantics_117;
14969                   break;
14970               }
14971             break;
14972           case 0xe6:
14973               GETBYTE ();
14974               switch (op[2] & 0x00)
14975               {
14976                 case 0x00:
14977                   goto op_semantics_117;
14978                   break;
14979               }
14980             break;
14981           case 0xe7:
14982               GETBYTE ();
14983               switch (op[2] & 0x00)
14984               {
14985                 case 0x00:
14986                   goto op_semantics_117;
14987                   break;
14988               }
14989             break;
14990           case 0xe8:
14991               GETBYTE ();
14992               switch (op[2] & 0x00)
14993               {
14994                 case 0x00:
14995                   goto op_semantics_117;
14996                   break;
14997               }
14998             break;
14999           case 0xe9:
15000               GETBYTE ();
15001               switch (op[2] & 0x00)
15002               {
15003                 case 0x00:
15004                   goto op_semantics_117;
15005                   break;
15006               }
15007             break;
15008           case 0xea:
15009               GETBYTE ();
15010               switch (op[2] & 0x00)
15011               {
15012                 case 0x00:
15013                   goto op_semantics_117;
15014                   break;
15015               }
15016             break;
15017           case 0xeb:
15018               GETBYTE ();
15019               switch (op[2] & 0x00)
15020               {
15021                 case 0x00:
15022                   goto op_semantics_117;
15023                   break;
15024               }
15025             break;
15026           case 0xec:
15027               GETBYTE ();
15028               switch (op[2] & 0x00)
15029               {
15030                 case 0x00:
15031                   goto op_semantics_117;
15032                   break;
15033               }
15034             break;
15035           case 0xed:
15036               GETBYTE ();
15037               switch (op[2] & 0x00)
15038               {
15039                 case 0x00:
15040                   goto op_semantics_117;
15041                   break;
15042               }
15043             break;
15044           case 0xee:
15045               GETBYTE ();
15046               switch (op[2] & 0x00)
15047               {
15048                 case 0x00:
15049                   goto op_semantics_117;
15050                   break;
15051               }
15052             break;
15053           case 0xef:
15054               GETBYTE ();
15055               switch (op[2] & 0x00)
15056               {
15057                 case 0x00:
15058                   goto op_semantics_117;
15059                   break;
15060               }
15061             break;
15062           default: UNSUPPORTED(); break;
15063         }
15064       break;
15065     case 0xff:
15066         GETBYTE ();
15067         switch (op[1] & 0xff)
15068         {
15069           case 0x00:
15070               GETBYTE ();
15071               switch (op[2] & 0x00)
15072               {
15073                 case 0x00:
15074                   op_semantics_118:
15075                     {
15076                       /** 1111 1111 0000 rdst srca srcb sub     %2, %1, %0 */
15077 #line 549 "rx-decode.opc"
15078                       int rdst AU = op[1] & 0x0f;
15079 #line 549 "rx-decode.opc"
15080                       int srca AU = (op[2] >> 4) & 0x0f;
15081 #line 549 "rx-decode.opc"
15082                       int srcb AU = op[2] & 0x0f;
15083                       if (trace)
15084                         {
15085                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15086                                  "/** 1111 1111 0000 rdst srca srcb     sub     %2, %1, %0 */",
15087                                  op[0], op[1], op[2]);
15088                           printf ("  rdst = 0x%x,", rdst);
15089                           printf ("  srca = 0x%x,", srca);
15090                           printf ("  srcb = 0x%x\n", srcb);
15091                         }
15092                       SYNTAX("sub       %2, %1, %0");
15093 #line 549 "rx-decode.opc"
15094                       ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15095
15096                     /*----------------------------------------------------------------------*/
15097                     /* SBB                                                                      */
15098
15099                     }
15100                   break;
15101               }
15102             break;
15103           case 0x01:
15104               GETBYTE ();
15105               switch (op[2] & 0x00)
15106               {
15107                 case 0x00:
15108                   goto op_semantics_118;
15109                   break;
15110               }
15111             break;
15112           case 0x02:
15113               GETBYTE ();
15114               switch (op[2] & 0x00)
15115               {
15116                 case 0x00:
15117                   goto op_semantics_118;
15118                   break;
15119               }
15120             break;
15121           case 0x03:
15122               GETBYTE ();
15123               switch (op[2] & 0x00)
15124               {
15125                 case 0x00:
15126                   goto op_semantics_118;
15127                   break;
15128               }
15129             break;
15130           case 0x04:
15131               GETBYTE ();
15132               switch (op[2] & 0x00)
15133               {
15134                 case 0x00:
15135                   goto op_semantics_118;
15136                   break;
15137               }
15138             break;
15139           case 0x05:
15140               GETBYTE ();
15141               switch (op[2] & 0x00)
15142               {
15143                 case 0x00:
15144                   goto op_semantics_118;
15145                   break;
15146               }
15147             break;
15148           case 0x06:
15149               GETBYTE ();
15150               switch (op[2] & 0x00)
15151               {
15152                 case 0x00:
15153                   goto op_semantics_118;
15154                   break;
15155               }
15156             break;
15157           case 0x07:
15158               GETBYTE ();
15159               switch (op[2] & 0x00)
15160               {
15161                 case 0x00:
15162                   goto op_semantics_118;
15163                   break;
15164               }
15165             break;
15166           case 0x08:
15167               GETBYTE ();
15168               switch (op[2] & 0x00)
15169               {
15170                 case 0x00:
15171                   goto op_semantics_118;
15172                   break;
15173               }
15174             break;
15175           case 0x09:
15176               GETBYTE ();
15177               switch (op[2] & 0x00)
15178               {
15179                 case 0x00:
15180                   goto op_semantics_118;
15181                   break;
15182               }
15183             break;
15184           case 0x0a:
15185               GETBYTE ();
15186               switch (op[2] & 0x00)
15187               {
15188                 case 0x00:
15189                   goto op_semantics_118;
15190                   break;
15191               }
15192             break;
15193           case 0x0b:
15194               GETBYTE ();
15195               switch (op[2] & 0x00)
15196               {
15197                 case 0x00:
15198                   goto op_semantics_118;
15199                   break;
15200               }
15201             break;
15202           case 0x0c:
15203               GETBYTE ();
15204               switch (op[2] & 0x00)
15205               {
15206                 case 0x00:
15207                   goto op_semantics_118;
15208                   break;
15209               }
15210             break;
15211           case 0x0d:
15212               GETBYTE ();
15213               switch (op[2] & 0x00)
15214               {
15215                 case 0x00:
15216                   goto op_semantics_118;
15217                   break;
15218               }
15219             break;
15220           case 0x0e:
15221               GETBYTE ();
15222               switch (op[2] & 0x00)
15223               {
15224                 case 0x00:
15225                   goto op_semantics_118;
15226                   break;
15227               }
15228             break;
15229           case 0x0f:
15230               GETBYTE ();
15231               switch (op[2] & 0x00)
15232               {
15233                 case 0x00:
15234                   goto op_semantics_118;
15235                   break;
15236               }
15237             break;
15238           case 0x20:
15239               GETBYTE ();
15240               switch (op[2] & 0x00)
15241               {
15242                 case 0x00:
15243                   op_semantics_119:
15244                     {
15245                       /** 1111 1111 0010 rdst srca srcb add     %2, %1, %0 */
15246 #line 516 "rx-decode.opc"
15247                       int rdst AU = op[1] & 0x0f;
15248 #line 516 "rx-decode.opc"
15249                       int srca AU = (op[2] >> 4) & 0x0f;
15250 #line 516 "rx-decode.opc"
15251                       int srcb AU = op[2] & 0x0f;
15252                       if (trace)
15253                         {
15254                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15255                                  "/** 1111 1111 0010 rdst srca srcb     add     %2, %1, %0 */",
15256                                  op[0], op[1], op[2]);
15257                           printf ("  rdst = 0x%x,", rdst);
15258                           printf ("  srca = 0x%x,", srca);
15259                           printf ("  srcb = 0x%x\n", srcb);
15260                         }
15261                       SYNTAX("add       %2, %1, %0");
15262 #line 516 "rx-decode.opc"
15263                       ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15264
15265                     /*----------------------------------------------------------------------*/
15266                     /* CMP                                                                      */
15267
15268                     }
15269                   break;
15270               }
15271             break;
15272           case 0x21:
15273               GETBYTE ();
15274               switch (op[2] & 0x00)
15275               {
15276                 case 0x00:
15277                   goto op_semantics_119;
15278                   break;
15279               }
15280             break;
15281           case 0x22:
15282               GETBYTE ();
15283               switch (op[2] & 0x00)
15284               {
15285                 case 0x00:
15286                   goto op_semantics_119;
15287                   break;
15288               }
15289             break;
15290           case 0x23:
15291               GETBYTE ();
15292               switch (op[2] & 0x00)
15293               {
15294                 case 0x00:
15295                   goto op_semantics_119;
15296                   break;
15297               }
15298             break;
15299           case 0x24:
15300               GETBYTE ();
15301               switch (op[2] & 0x00)
15302               {
15303                 case 0x00:
15304                   goto op_semantics_119;
15305                   break;
15306               }
15307             break;
15308           case 0x25:
15309               GETBYTE ();
15310               switch (op[2] & 0x00)
15311               {
15312                 case 0x00:
15313                   goto op_semantics_119;
15314                   break;
15315               }
15316             break;
15317           case 0x26:
15318               GETBYTE ();
15319               switch (op[2] & 0x00)
15320               {
15321                 case 0x00:
15322                   goto op_semantics_119;
15323                   break;
15324               }
15325             break;
15326           case 0x27:
15327               GETBYTE ();
15328               switch (op[2] & 0x00)
15329               {
15330                 case 0x00:
15331                   goto op_semantics_119;
15332                   break;
15333               }
15334             break;
15335           case 0x28:
15336               GETBYTE ();
15337               switch (op[2] & 0x00)
15338               {
15339                 case 0x00:
15340                   goto op_semantics_119;
15341                   break;
15342               }
15343             break;
15344           case 0x29:
15345               GETBYTE ();
15346               switch (op[2] & 0x00)
15347               {
15348                 case 0x00:
15349                   goto op_semantics_119;
15350                   break;
15351               }
15352             break;
15353           case 0x2a:
15354               GETBYTE ();
15355               switch (op[2] & 0x00)
15356               {
15357                 case 0x00:
15358                   goto op_semantics_119;
15359                   break;
15360               }
15361             break;
15362           case 0x2b:
15363               GETBYTE ();
15364               switch (op[2] & 0x00)
15365               {
15366                 case 0x00:
15367                   goto op_semantics_119;
15368                   break;
15369               }
15370             break;
15371           case 0x2c:
15372               GETBYTE ();
15373               switch (op[2] & 0x00)
15374               {
15375                 case 0x00:
15376                   goto op_semantics_119;
15377                   break;
15378               }
15379             break;
15380           case 0x2d:
15381               GETBYTE ();
15382               switch (op[2] & 0x00)
15383               {
15384                 case 0x00:
15385                   goto op_semantics_119;
15386                   break;
15387               }
15388             break;
15389           case 0x2e:
15390               GETBYTE ();
15391               switch (op[2] & 0x00)
15392               {
15393                 case 0x00:
15394                   goto op_semantics_119;
15395                   break;
15396               }
15397             break;
15398           case 0x2f:
15399               GETBYTE ();
15400               switch (op[2] & 0x00)
15401               {
15402                 case 0x00:
15403                   goto op_semantics_119;
15404                   break;
15405               }
15406             break;
15407           case 0x30:
15408               GETBYTE ();
15409               switch (op[2] & 0x00)
15410               {
15411                 case 0x00:
15412                   op_semantics_120:
15413                     {
15414                       /** 1111 1111 0011 rdst srca srcb mul     %2, %1, %0 */
15415 #line 656 "rx-decode.opc"
15416                       int rdst AU = op[1] & 0x0f;
15417 #line 656 "rx-decode.opc"
15418                       int srca AU = (op[2] >> 4) & 0x0f;
15419 #line 656 "rx-decode.opc"
15420                       int srcb AU = op[2] & 0x0f;
15421                       if (trace)
15422                         {
15423                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15424                                  "/** 1111 1111 0011 rdst srca srcb     mul     %2, %1, %0 */",
15425                                  op[0], op[1], op[2]);
15426                           printf ("  rdst = 0x%x,", rdst);
15427                           printf ("  srca = 0x%x,", srca);
15428                           printf ("  srcb = 0x%x\n", srcb);
15429                         }
15430                       SYNTAX("mul       %2, %1, %0");
15431 #line 656 "rx-decode.opc"
15432                       ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
15433
15434                     /*----------------------------------------------------------------------*/
15435                     /* EMUL                                                                     */
15436
15437                     }
15438                   break;
15439               }
15440             break;
15441           case 0x31:
15442               GETBYTE ();
15443               switch (op[2] & 0x00)
15444               {
15445                 case 0x00:
15446                   goto op_semantics_120;
15447                   break;
15448               }
15449             break;
15450           case 0x32:
15451               GETBYTE ();
15452               switch (op[2] & 0x00)
15453               {
15454                 case 0x00:
15455                   goto op_semantics_120;
15456                   break;
15457               }
15458             break;
15459           case 0x33:
15460               GETBYTE ();
15461               switch (op[2] & 0x00)
15462               {
15463                 case 0x00:
15464                   goto op_semantics_120;
15465                   break;
15466               }
15467             break;
15468           case 0x34:
15469               GETBYTE ();
15470               switch (op[2] & 0x00)
15471               {
15472                 case 0x00:
15473                   goto op_semantics_120;
15474                   break;
15475               }
15476             break;
15477           case 0x35:
15478               GETBYTE ();
15479               switch (op[2] & 0x00)
15480               {
15481                 case 0x00:
15482                   goto op_semantics_120;
15483                   break;
15484               }
15485             break;
15486           case 0x36:
15487               GETBYTE ();
15488               switch (op[2] & 0x00)
15489               {
15490                 case 0x00:
15491                   goto op_semantics_120;
15492                   break;
15493               }
15494             break;
15495           case 0x37:
15496               GETBYTE ();
15497               switch (op[2] & 0x00)
15498               {
15499                 case 0x00:
15500                   goto op_semantics_120;
15501                   break;
15502               }
15503             break;
15504           case 0x38:
15505               GETBYTE ();
15506               switch (op[2] & 0x00)
15507               {
15508                 case 0x00:
15509                   goto op_semantics_120;
15510                   break;
15511               }
15512             break;
15513           case 0x39:
15514               GETBYTE ();
15515               switch (op[2] & 0x00)
15516               {
15517                 case 0x00:
15518                   goto op_semantics_120;
15519                   break;
15520               }
15521             break;
15522           case 0x3a:
15523               GETBYTE ();
15524               switch (op[2] & 0x00)
15525               {
15526                 case 0x00:
15527                   goto op_semantics_120;
15528                   break;
15529               }
15530             break;
15531           case 0x3b:
15532               GETBYTE ();
15533               switch (op[2] & 0x00)
15534               {
15535                 case 0x00:
15536                   goto op_semantics_120;
15537                   break;
15538               }
15539             break;
15540           case 0x3c:
15541               GETBYTE ();
15542               switch (op[2] & 0x00)
15543               {
15544                 case 0x00:
15545                   goto op_semantics_120;
15546                   break;
15547               }
15548             break;
15549           case 0x3d:
15550               GETBYTE ();
15551               switch (op[2] & 0x00)
15552               {
15553                 case 0x00:
15554                   goto op_semantics_120;
15555                   break;
15556               }
15557             break;
15558           case 0x3e:
15559               GETBYTE ();
15560               switch (op[2] & 0x00)
15561               {
15562                 case 0x00:
15563                   goto op_semantics_120;
15564                   break;
15565               }
15566             break;
15567           case 0x3f:
15568               GETBYTE ();
15569               switch (op[2] & 0x00)
15570               {
15571                 case 0x00:
15572                   goto op_semantics_120;
15573                   break;
15574               }
15575             break;
15576           case 0x40:
15577               GETBYTE ();
15578               switch (op[2] & 0x00)
15579               {
15580                 case 0x00:
15581                   op_semantics_121:
15582                     {
15583                       /** 1111 1111 0100 rdst srca srcb and     %2, %1, %0 */
15584 #line 426 "rx-decode.opc"
15585                       int rdst AU = op[1] & 0x0f;
15586 #line 426 "rx-decode.opc"
15587                       int srca AU = (op[2] >> 4) & 0x0f;
15588 #line 426 "rx-decode.opc"
15589                       int srcb AU = op[2] & 0x0f;
15590                       if (trace)
15591                         {
15592                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15593                                  "/** 1111 1111 0100 rdst srca srcb     and     %2, %1, %0 */",
15594                                  op[0], op[1], op[2]);
15595                           printf ("  rdst = 0x%x,", rdst);
15596                           printf ("  srca = 0x%x,", srca);
15597                           printf ("  srcb = 0x%x\n", srcb);
15598                         }
15599                       SYNTAX("and       %2, %1, %0");
15600 #line 426 "rx-decode.opc"
15601                       ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15602
15603                     /*----------------------------------------------------------------------*/
15604                     /* OR                                                                       */
15605
15606                     }
15607                   break;
15608               }
15609             break;
15610           case 0x41:
15611               GETBYTE ();
15612               switch (op[2] & 0x00)
15613               {
15614                 case 0x00:
15615                   goto op_semantics_121;
15616                   break;
15617               }
15618             break;
15619           case 0x42:
15620               GETBYTE ();
15621               switch (op[2] & 0x00)
15622               {
15623                 case 0x00:
15624                   goto op_semantics_121;
15625                   break;
15626               }
15627             break;
15628           case 0x43:
15629               GETBYTE ();
15630               switch (op[2] & 0x00)
15631               {
15632                 case 0x00:
15633                   goto op_semantics_121;
15634                   break;
15635               }
15636             break;
15637           case 0x44:
15638               GETBYTE ();
15639               switch (op[2] & 0x00)
15640               {
15641                 case 0x00:
15642                   goto op_semantics_121;
15643                   break;
15644               }
15645             break;
15646           case 0x45:
15647               GETBYTE ();
15648               switch (op[2] & 0x00)
15649               {
15650                 case 0x00:
15651                   goto op_semantics_121;
15652                   break;
15653               }
15654             break;
15655           case 0x46:
15656               GETBYTE ();
15657               switch (op[2] & 0x00)
15658               {
15659                 case 0x00:
15660                   goto op_semantics_121;
15661                   break;
15662               }
15663             break;
15664           case 0x47:
15665               GETBYTE ();
15666               switch (op[2] & 0x00)
15667               {
15668                 case 0x00:
15669                   goto op_semantics_121;
15670                   break;
15671               }
15672             break;
15673           case 0x48:
15674               GETBYTE ();
15675               switch (op[2] & 0x00)
15676               {
15677                 case 0x00:
15678                   goto op_semantics_121;
15679                   break;
15680               }
15681             break;
15682           case 0x49:
15683               GETBYTE ();
15684               switch (op[2] & 0x00)
15685               {
15686                 case 0x00:
15687                   goto op_semantics_121;
15688                   break;
15689               }
15690             break;
15691           case 0x4a:
15692               GETBYTE ();
15693               switch (op[2] & 0x00)
15694               {
15695                 case 0x00:
15696                   goto op_semantics_121;
15697                   break;
15698               }
15699             break;
15700           case 0x4b:
15701               GETBYTE ();
15702               switch (op[2] & 0x00)
15703               {
15704                 case 0x00:
15705                   goto op_semantics_121;
15706                   break;
15707               }
15708             break;
15709           case 0x4c:
15710               GETBYTE ();
15711               switch (op[2] & 0x00)
15712               {
15713                 case 0x00:
15714                   goto op_semantics_121;
15715                   break;
15716               }
15717             break;
15718           case 0x4d:
15719               GETBYTE ();
15720               switch (op[2] & 0x00)
15721               {
15722                 case 0x00:
15723                   goto op_semantics_121;
15724                   break;
15725               }
15726             break;
15727           case 0x4e:
15728               GETBYTE ();
15729               switch (op[2] & 0x00)
15730               {
15731                 case 0x00:
15732                   goto op_semantics_121;
15733                   break;
15734               }
15735             break;
15736           case 0x4f:
15737               GETBYTE ();
15738               switch (op[2] & 0x00)
15739               {
15740                 case 0x00:
15741                   goto op_semantics_121;
15742                   break;
15743               }
15744             break;
15745           case 0x50:
15746               GETBYTE ();
15747               switch (op[2] & 0x00)
15748               {
15749                 case 0x00:
15750                   op_semantics_122:
15751                     {
15752                       /** 1111 1111 0101 rdst srca srcb or      %2, %1, %0 */
15753 #line 444 "rx-decode.opc"
15754                       int rdst AU = op[1] & 0x0f;
15755 #line 444 "rx-decode.opc"
15756                       int srca AU = (op[2] >> 4) & 0x0f;
15757 #line 444 "rx-decode.opc"
15758                       int srcb AU = op[2] & 0x0f;
15759                       if (trace)
15760                         {
15761                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15762                                  "/** 1111 1111 0101 rdst srca srcb     or      %2, %1, %0 */",
15763                                  op[0], op[1], op[2]);
15764                           printf ("  rdst = 0x%x,", rdst);
15765                           printf ("  srca = 0x%x,", srca);
15766                           printf ("  srcb = 0x%x\n", srcb);
15767                         }
15768                       SYNTAX("or        %2, %1, %0");
15769 #line 444 "rx-decode.opc"
15770                       ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15771
15772                     /*----------------------------------------------------------------------*/
15773                     /* XOR                                                                      */
15774
15775                     }
15776                   break;
15777               }
15778             break;
15779           case 0x51:
15780               GETBYTE ();
15781               switch (op[2] & 0x00)
15782               {
15783                 case 0x00:
15784                   goto op_semantics_122;
15785                   break;
15786               }
15787             break;
15788           case 0x52:
15789               GETBYTE ();
15790               switch (op[2] & 0x00)
15791               {
15792                 case 0x00:
15793                   goto op_semantics_122;
15794                   break;
15795               }
15796             break;
15797           case 0x53:
15798               GETBYTE ();
15799               switch (op[2] & 0x00)
15800               {
15801                 case 0x00:
15802                   goto op_semantics_122;
15803                   break;
15804               }
15805             break;
15806           case 0x54:
15807               GETBYTE ();
15808               switch (op[2] & 0x00)
15809               {
15810                 case 0x00:
15811                   goto op_semantics_122;
15812                   break;
15813               }
15814             break;
15815           case 0x55:
15816               GETBYTE ();
15817               switch (op[2] & 0x00)
15818               {
15819                 case 0x00:
15820                   goto op_semantics_122;
15821                   break;
15822               }
15823             break;
15824           case 0x56:
15825               GETBYTE ();
15826               switch (op[2] & 0x00)
15827               {
15828                 case 0x00:
15829                   goto op_semantics_122;
15830                   break;
15831               }
15832             break;
15833           case 0x57:
15834               GETBYTE ();
15835               switch (op[2] & 0x00)
15836               {
15837                 case 0x00:
15838                   goto op_semantics_122;
15839                   break;
15840               }
15841             break;
15842           case 0x58:
15843               GETBYTE ();
15844               switch (op[2] & 0x00)
15845               {
15846                 case 0x00:
15847                   goto op_semantics_122;
15848                   break;
15849               }
15850             break;
15851           case 0x59:
15852               GETBYTE ();
15853               switch (op[2] & 0x00)
15854               {
15855                 case 0x00:
15856                   goto op_semantics_122;
15857                   break;
15858               }
15859             break;
15860           case 0x5a:
15861               GETBYTE ();
15862               switch (op[2] & 0x00)
15863               {
15864                 case 0x00:
15865                   goto op_semantics_122;
15866                   break;
15867               }
15868             break;
15869           case 0x5b:
15870               GETBYTE ();
15871               switch (op[2] & 0x00)
15872               {
15873                 case 0x00:
15874                   goto op_semantics_122;
15875                   break;
15876               }
15877             break;
15878           case 0x5c:
15879               GETBYTE ();
15880               switch (op[2] & 0x00)
15881               {
15882                 case 0x00:
15883                   goto op_semantics_122;
15884                   break;
15885               }
15886             break;
15887           case 0x5d:
15888               GETBYTE ();
15889               switch (op[2] & 0x00)
15890               {
15891                 case 0x00:
15892                   goto op_semantics_122;
15893                   break;
15894               }
15895             break;
15896           case 0x5e:
15897               GETBYTE ();
15898               switch (op[2] & 0x00)
15899               {
15900                 case 0x00:
15901                   goto op_semantics_122;
15902                   break;
15903               }
15904             break;
15905           case 0x5f:
15906               GETBYTE ();
15907               switch (op[2] & 0x00)
15908               {
15909                 case 0x00:
15910                   goto op_semantics_122;
15911                   break;
15912               }
15913             break;
15914           case 0x80:
15915               GETBYTE ();
15916               switch (op[2] & 0x00)
15917               {
15918                 case 0x00:
15919                   op_semantics_123:
15920                     {
15921                       /** 1111 1111 1000 rdst srca srcb fsub    %2, %1, %0 */
15922 #line 1104 "rx-decode.opc"
15923                       int rdst AU = op[1] & 0x0f;
15924 #line 1104 "rx-decode.opc"
15925                       int srca AU = (op[2] >> 4) & 0x0f;
15926 #line 1104 "rx-decode.opc"
15927                       int srcb AU = op[2] & 0x0f;
15928                       if (trace)
15929                         {
15930                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15931                                  "/** 1111 1111 1000 rdst srca srcb     fsub    %2, %1, %0 */",
15932                                  op[0], op[1], op[2]);
15933                           printf ("  rdst = 0x%x,", rdst);
15934                           printf ("  srca = 0x%x,", srca);
15935                           printf ("  srcb = 0x%x\n", srcb);
15936                         }
15937                       SYNTAX("fsub      %2, %1, %0");
15938 #line 1104 "rx-decode.opc"
15939                       ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15940
15941                     }
15942                   break;
15943               }
15944             break;
15945           case 0x81:
15946               GETBYTE ();
15947               switch (op[2] & 0x00)
15948               {
15949                 case 0x00:
15950                   goto op_semantics_123;
15951                   break;
15952               }
15953             break;
15954           case 0x82:
15955               GETBYTE ();
15956               switch (op[2] & 0x00)
15957               {
15958                 case 0x00:
15959                   goto op_semantics_123;
15960                   break;
15961               }
15962             break;
15963           case 0x83:
15964               GETBYTE ();
15965               switch (op[2] & 0x00)
15966               {
15967                 case 0x00:
15968                   goto op_semantics_123;
15969                   break;
15970               }
15971             break;
15972           case 0x84:
15973               GETBYTE ();
15974               switch (op[2] & 0x00)
15975               {
15976                 case 0x00:
15977                   goto op_semantics_123;
15978                   break;
15979               }
15980             break;
15981           case 0x85:
15982               GETBYTE ();
15983               switch (op[2] & 0x00)
15984               {
15985                 case 0x00:
15986                   goto op_semantics_123;
15987                   break;
15988               }
15989             break;
15990           case 0x86:
15991               GETBYTE ();
15992               switch (op[2] & 0x00)
15993               {
15994                 case 0x00:
15995                   goto op_semantics_123;
15996                   break;
15997               }
15998             break;
15999           case 0x87:
16000               GETBYTE ();
16001               switch (op[2] & 0x00)
16002               {
16003                 case 0x00:
16004                   goto op_semantics_123;
16005                   break;
16006               }
16007             break;
16008           case 0x88:
16009               GETBYTE ();
16010               switch (op[2] & 0x00)
16011               {
16012                 case 0x00:
16013                   goto op_semantics_123;
16014                   break;
16015               }
16016             break;
16017           case 0x89:
16018               GETBYTE ();
16019               switch (op[2] & 0x00)
16020               {
16021                 case 0x00:
16022                   goto op_semantics_123;
16023                   break;
16024               }
16025             break;
16026           case 0x8a:
16027               GETBYTE ();
16028               switch (op[2] & 0x00)
16029               {
16030                 case 0x00:
16031                   goto op_semantics_123;
16032                   break;
16033               }
16034             break;
16035           case 0x8b:
16036               GETBYTE ();
16037               switch (op[2] & 0x00)
16038               {
16039                 case 0x00:
16040                   goto op_semantics_123;
16041                   break;
16042               }
16043             break;
16044           case 0x8c:
16045               GETBYTE ();
16046               switch (op[2] & 0x00)
16047               {
16048                 case 0x00:
16049                   goto op_semantics_123;
16050                   break;
16051               }
16052             break;
16053           case 0x8d:
16054               GETBYTE ();
16055               switch (op[2] & 0x00)
16056               {
16057                 case 0x00:
16058                   goto op_semantics_123;
16059                   break;
16060               }
16061             break;
16062           case 0x8e:
16063               GETBYTE ();
16064               switch (op[2] & 0x00)
16065               {
16066                 case 0x00:
16067                   goto op_semantics_123;
16068                   break;
16069               }
16070             break;
16071           case 0x8f:
16072               GETBYTE ();
16073               switch (op[2] & 0x00)
16074               {
16075                 case 0x00:
16076                   goto op_semantics_123;
16077                   break;
16078               }
16079             break;
16080           case 0xa0:
16081               GETBYTE ();
16082               switch (op[2] & 0x00)
16083               {
16084                 case 0x00:
16085                   op_semantics_124:
16086                     {
16087                       /** 1111 1111 1010 rdst srca srcb fadd    %2, %1, %0 */
16088 #line 1101 "rx-decode.opc"
16089                       int rdst AU = op[1] & 0x0f;
16090 #line 1101 "rx-decode.opc"
16091                       int srca AU = (op[2] >> 4) & 0x0f;
16092 #line 1101 "rx-decode.opc"
16093                       int srcb AU = op[2] & 0x0f;
16094                       if (trace)
16095                         {
16096                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16097                                  "/** 1111 1111 1010 rdst srca srcb     fadd    %2, %1, %0 */",
16098                                  op[0], op[1], op[2]);
16099                           printf ("  rdst = 0x%x,", rdst);
16100                           printf ("  srca = 0x%x,", srca);
16101                           printf ("  srcb = 0x%x\n", srcb);
16102                         }
16103                       SYNTAX("fadd      %2, %1, %0");
16104 #line 1101 "rx-decode.opc"
16105                       ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
16106
16107                     }
16108                   break;
16109               }
16110             break;
16111           case 0xa1:
16112               GETBYTE ();
16113               switch (op[2] & 0x00)
16114               {
16115                 case 0x00:
16116                   goto op_semantics_124;
16117                   break;
16118               }
16119             break;
16120           case 0xa2:
16121               GETBYTE ();
16122               switch (op[2] & 0x00)
16123               {
16124                 case 0x00:
16125                   goto op_semantics_124;
16126                   break;
16127               }
16128             break;
16129           case 0xa3:
16130               GETBYTE ();
16131               switch (op[2] & 0x00)
16132               {
16133                 case 0x00:
16134                   goto op_semantics_124;
16135                   break;
16136               }
16137             break;
16138           case 0xa4:
16139               GETBYTE ();
16140               switch (op[2] & 0x00)
16141               {
16142                 case 0x00:
16143                   goto op_semantics_124;
16144                   break;
16145               }
16146             break;
16147           case 0xa5:
16148               GETBYTE ();
16149               switch (op[2] & 0x00)
16150               {
16151                 case 0x00:
16152                   goto op_semantics_124;
16153                   break;
16154               }
16155             break;
16156           case 0xa6:
16157               GETBYTE ();
16158               switch (op[2] & 0x00)
16159               {
16160                 case 0x00:
16161                   goto op_semantics_124;
16162                   break;
16163               }
16164             break;
16165           case 0xa7:
16166               GETBYTE ();
16167               switch (op[2] & 0x00)
16168               {
16169                 case 0x00:
16170                   goto op_semantics_124;
16171                   break;
16172               }
16173             break;
16174           case 0xa8:
16175               GETBYTE ();
16176               switch (op[2] & 0x00)
16177               {
16178                 case 0x00:
16179                   goto op_semantics_124;
16180                   break;
16181               }
16182             break;
16183           case 0xa9:
16184               GETBYTE ();
16185               switch (op[2] & 0x00)
16186               {
16187                 case 0x00:
16188                   goto op_semantics_124;
16189                   break;
16190               }
16191             break;
16192           case 0xaa:
16193               GETBYTE ();
16194               switch (op[2] & 0x00)
16195               {
16196                 case 0x00:
16197                   goto op_semantics_124;
16198                   break;
16199               }
16200             break;
16201           case 0xab:
16202               GETBYTE ();
16203               switch (op[2] & 0x00)
16204               {
16205                 case 0x00:
16206                   goto op_semantics_124;
16207                   break;
16208               }
16209             break;
16210           case 0xac:
16211               GETBYTE ();
16212               switch (op[2] & 0x00)
16213               {
16214                 case 0x00:
16215                   goto op_semantics_124;
16216                   break;
16217               }
16218             break;
16219           case 0xad:
16220               GETBYTE ();
16221               switch (op[2] & 0x00)
16222               {
16223                 case 0x00:
16224                   goto op_semantics_124;
16225                   break;
16226               }
16227             break;
16228           case 0xae:
16229               GETBYTE ();
16230               switch (op[2] & 0x00)
16231               {
16232                 case 0x00:
16233                   goto op_semantics_124;
16234                   break;
16235               }
16236             break;
16237           case 0xaf:
16238               GETBYTE ();
16239               switch (op[2] & 0x00)
16240               {
16241                 case 0x00:
16242                   goto op_semantics_124;
16243                   break;
16244               }
16245             break;
16246           case 0xb0:
16247               GETBYTE ();
16248               switch (op[2] & 0x00)
16249               {
16250                 case 0x00:
16251                   op_semantics_125:
16252                     {
16253                       /** 1111 1111 1011 rdst srca srcb fmul    %2, %1, %0 */
16254 #line 1107 "rx-decode.opc"
16255                       int rdst AU = op[1] & 0x0f;
16256 #line 1107 "rx-decode.opc"
16257                       int srca AU = (op[2] >> 4) & 0x0f;
16258 #line 1107 "rx-decode.opc"
16259                       int srcb AU = op[2] & 0x0f;
16260                       if (trace)
16261                         {
16262                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16263                                  "/** 1111 1111 1011 rdst srca srcb     fmul    %2, %1, %0 */",
16264                                  op[0], op[1], op[2]);
16265                           printf ("  rdst = 0x%x,", rdst);
16266                           printf ("  srca = 0x%x,", srca);
16267                           printf ("  srcb = 0x%x\n", srcb);
16268                         }
16269                       SYNTAX("fmul      %2, %1, %0");
16270 #line 1107 "rx-decode.opc"
16271                       ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
16272
16273                     }
16274                   break;
16275               }
16276             break;
16277           case 0xb1:
16278               GETBYTE ();
16279               switch (op[2] & 0x00)
16280               {
16281                 case 0x00:
16282                   goto op_semantics_125;
16283                   break;
16284               }
16285             break;
16286           case 0xb2:
16287               GETBYTE ();
16288               switch (op[2] & 0x00)
16289               {
16290                 case 0x00:
16291                   goto op_semantics_125;
16292                   break;
16293               }
16294             break;
16295           case 0xb3:
16296               GETBYTE ();
16297               switch (op[2] & 0x00)
16298               {
16299                 case 0x00:
16300                   goto op_semantics_125;
16301                   break;
16302               }
16303             break;
16304           case 0xb4:
16305               GETBYTE ();
16306               switch (op[2] & 0x00)
16307               {
16308                 case 0x00:
16309                   goto op_semantics_125;
16310                   break;
16311               }
16312             break;
16313           case 0xb5:
16314               GETBYTE ();
16315               switch (op[2] & 0x00)
16316               {
16317                 case 0x00:
16318                   goto op_semantics_125;
16319                   break;
16320               }
16321             break;
16322           case 0xb6:
16323               GETBYTE ();
16324               switch (op[2] & 0x00)
16325               {
16326                 case 0x00:
16327                   goto op_semantics_125;
16328                   break;
16329               }
16330             break;
16331           case 0xb7:
16332               GETBYTE ();
16333               switch (op[2] & 0x00)
16334               {
16335                 case 0x00:
16336                   goto op_semantics_125;
16337                   break;
16338               }
16339             break;
16340           case 0xb8:
16341               GETBYTE ();
16342               switch (op[2] & 0x00)
16343               {
16344                 case 0x00:
16345                   goto op_semantics_125;
16346                   break;
16347               }
16348             break;
16349           case 0xb9:
16350               GETBYTE ();
16351               switch (op[2] & 0x00)
16352               {
16353                 case 0x00:
16354                   goto op_semantics_125;
16355                   break;
16356               }
16357             break;
16358           case 0xba:
16359               GETBYTE ();
16360               switch (op[2] & 0x00)
16361               {
16362                 case 0x00:
16363                   goto op_semantics_125;
16364                   break;
16365               }
16366             break;
16367           case 0xbb:
16368               GETBYTE ();
16369               switch (op[2] & 0x00)
16370               {
16371                 case 0x00:
16372                   goto op_semantics_125;
16373                   break;
16374               }
16375             break;
16376           case 0xbc:
16377               GETBYTE ();
16378               switch (op[2] & 0x00)
16379               {
16380                 case 0x00:
16381                   goto op_semantics_125;
16382                   break;
16383               }
16384             break;
16385           case 0xbd:
16386               GETBYTE ();
16387               switch (op[2] & 0x00)
16388               {
16389                 case 0x00:
16390                   goto op_semantics_125;
16391                   break;
16392               }
16393             break;
16394           case 0xbe:
16395               GETBYTE ();
16396               switch (op[2] & 0x00)
16397               {
16398                 case 0x00:
16399                   goto op_semantics_125;
16400                   break;
16401               }
16402             break;
16403           case 0xbf:
16404               GETBYTE ();
16405               switch (op[2] & 0x00)
16406               {
16407                 case 0x00:
16408                   goto op_semantics_125;
16409                   break;
16410               }
16411             break;
16412           default: UNSUPPORTED(); break;
16413         }
16414       break;
16415     default: UNSUPPORTED(); break;
16416   }
16417 #line 1122 "rx-decode.opc"
16418
16419   return rx->n_bytes;
16420 }