opcodes/rx-decode.c

   1 #line 1 "rx-decode.opc"
   2 /* -*- c -*- */
   3 /* Copyright (C) 2012-2015 Free Software Foundation, Inc.
   4    Contributed by Red Hat.
   5    Written by DJ Delorie.
   6
   7    This file is part of the GNU opcodes library.
   8
   9    This library is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3, or (at your option)
  12    any later version.
  13
  14    It is distributed in the hope that it will be useful, but WITHOUT
  15    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  17    License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 #include "sysdep.h"
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include "ansidecl.h"
  29 #include "opcode/rx.h"
  30
  31 #define RX_OPCODE_BIG_ENDIAN 0
  32
  33 typedef struct
  34 {
  35   RX_Opcode_Decoded * rx;
  36   int (* getbyte)(void *);
  37   void * ptr;
  38   unsigned char * op;
  39 } LocalData;
  40
  41 static int trace = 0;
  42
  43 #define BSIZE 0
  44 #define WSIZE 1
  45 #define LSIZE 2
  46
  47 /* These are for when the upper bits are "don't care" or "undefined".  */
  48 static int bwl[] =
  49 {
  50   RX_Byte,
  51   RX_Word,
  52   RX_Long,
  53   RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
  54 };
  55
  56 static int sbwl[] =
  57 {
  58   RX_SByte,
  59   RX_SWord,
  60   RX_Long,
  61   RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
  62 };
  63
  64 static int ubw[] =
  65 {
  66   RX_UByte,
  67   RX_UWord,
  68   RX_Bad_Size,/* Bogus instructions can have a size field set to 2.  */
  69   RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
  70 };
  71
  72 static int memex[] =
  73 {
  74   RX_SByte,
  75   RX_SWord,
  76   RX_Long,
  77   RX_UWord
  78 };
  79
  80 #define ID(x) rx->id = RXO_##x
  81 #define OP(n,t,r,a) (rx->op[n].type = t, \
  82                      rx->op[n].reg = r,      \
  83                      rx->op[n].addend = a )
  84 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
  85                         rx->op[n].size = s )
  86
  87 /* This is for the BWL and BW bitfields.  */
  88 static int SCALE[] = { 1, 2, 4, 0 };
  89 /* This is for the prefix size enum.  */
  90 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
  91
  92 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
  93                        16, 17, 0, 0, 0, 0, 0, 0 };
  94
  95 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
  96
  97 /*
  98  *C     a constant (immediate) c
  99  *R     A register
 100  *I     Register indirect, no offset
 101  *Is    Register indirect, with offset
 102  *D     standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
 103  *P     standard displacement: type (r,[r]), reg, assumes UByte
 104  *Pm    memex displacement: type (r,[r]), reg, memex code
 105  *cc    condition code.  */
 106
 107 #define DC(c)       OP (0, RX_Operand_Immediate, 0, c)
 108 #define DR(r)       OP (0, RX_Operand_Register,  r, 0)
 109 #define DI(r,a)     OP (0, RX_Operand_Indirect,  r, a)
 110 #define DIs(r,a,s)  OP (0, RX_Operand_Indirect,  r, (a) * SCALE[s])
 111 #define DD(t,r,s)   rx_disp (0, t, r, bwl[s], ld);
 112 #define DF(r)       OP (0, RX_Operand_Flag,  flagmap[r], 0)
 113
 114 #define SC(i)       OP (1, RX_Operand_Immediate, 0, i)
 115 #define SR(r)       OP (1, RX_Operand_Register,  r, 0)
 116 #define SRR(r)      OP (1, RX_Operand_TwoReg,  r, 0)
 117 #define SI(r,a)     OP (1, RX_Operand_Indirect,  r, a)
 118 #define SIs(r,a,s)  OP (1, RX_Operand_Indirect,  r, (a) * SCALE[s])
 119 #define SD(t,r,s)   rx_disp (1, t, r, bwl[s], ld);
 120 #define SP(t,r)     rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
 121 #define SPm(t,r,m)  rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
 122 #define Scc(cc)     OP (1, RX_Operand_Condition,  cc, 0)
 123
 124 #define S2C(i)      OP (2, RX_Operand_Immediate, 0, i)
 125 #define S2R(r)      OP (2, RX_Operand_Register,  r, 0)
 126 #define S2I(r,a)    OP (2, RX_Operand_Indirect,  r, a)
 127 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect,  r, (a) * SCALE[s])
 128 #define S2D(t,r,s)  rx_disp (2, t, r, bwl[s], ld);
 129 #define S2P(t,r)    rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
 130 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
 131 #define S2cc(cc)    OP (2, RX_Operand_Condition,  cc, 0)
 132
 133 #define BWL(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
 134 #define sBWL(sz)    rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
 135 #define uBW(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
 136 #define P(t, n)     rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
 137
 138 #define F(f) store_flags(rx, f)
 139
 140 #define AU ATTRIBUTE_UNUSED
 141 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
 142
 143 #define SYNTAX(x) rx->syntax = x
 144
 145 #define UNSUPPORTED() \
 146   rx->syntax = "*unknown*"
 147
 148 #define IMM(sf)   immediate (sf, 0, ld)
 149 #define IMMex(sf) immediate (sf, 1, ld)
 150
 151 static int
 152 immediate (int sfield, int ex, LocalData * ld)
 153 {
 154   unsigned long i = 0, j;
 155
 156   switch (sfield)
 157     {
 158 #define B ((unsigned long) GETBYTE())
 159     case 0:
 160 #if RX_OPCODE_BIG_ENDIAN
 161       i  = B;
 162       if (ex && (i & 0x80))
 163         i -= 0x100;
 164       i <<= 24;
 165       i |= B << 16;
 166       i |= B << 8;
 167       i |= B;
 168 #else
 169       i = B;
 170       i |= B << 8;
 171       i |= B << 16;
 172       j = B;
 173       if (ex && (j & 0x80))
 174         j -= 0x100;
 175       i |= j << 24;
 176 #endif
 177       break;
 178     case 3:
 179 #if RX_OPCODE_BIG_ENDIAN
 180       i  = B << 16;
 181       i |= B << 8;
 182       i |= B;
 183 #else
 184       i  = B;
 185       i |= B << 8;
 186       i |= B << 16;
 187 #endif
 188       if (ex && (i & 0x800000))
 189         i -= 0x1000000;
 190       break;
 191     case 2:
 192 #if RX_OPCODE_BIG_ENDIAN
 193       i |= B << 8;
 194       i |= B;
 195 #else
 196       i |= B;
 197       i |= B << 8;
 198 #endif
 199       if (ex && (i & 0x8000))
 200         i -= 0x10000;
 201       break;
 202     case 1:
 203       i |= B;
 204       if (ex && (i & 0x80))
 205         i -= 0x100;
 206       break;
 207     default:
 208       abort();
 209     }
 210   return i;
 211 }
 212
 213 static void
 214 rx_disp (int n, int type, int reg, int size, LocalData * ld)
 215 {
 216   int disp;
 217
 218   ld->rx->op[n].reg = reg;
 219   switch (type)
 220     {
 221     case 3:
 222       ld->rx->op[n].type = RX_Operand_Register;
 223       break;
 224     case 0:
 225       ld->rx->op[n].type = RX_Operand_Zero_Indirect;
 226       ld->rx->op[n].addend = 0;
 227       break;
 228     case 1:
 229       ld->rx->op[n].type = RX_Operand_Indirect;
 230       disp = GETBYTE ();
 231       ld->rx->op[n].addend = disp * PSCALE[size];
 232       break;
 233     case 2:
 234       ld->rx->op[n].type = RX_Operand_Indirect;
 235       disp = GETBYTE ();
 236 #if RX_OPCODE_BIG_ENDIAN
 237       disp = disp * 256 + GETBYTE ();
 238 #else
 239       disp = disp + GETBYTE () * 256;
 240 #endif
 241       ld->rx->op[n].addend = disp * PSCALE[size];
 242       break;
 243     default:
 244       abort ();
 245     }
 246 }
 247
 248 #define xO 8
 249 #define xS 4
 250 #define xZ 2
 251 #define xC 1
 252
 253 #define F_____
 254 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
 255 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
 256 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
 257 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
 258 #define F_O___ rx->flags_0 = rx->flags_s = xO;
 259 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
 260 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
 261 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
 262
 263 int
 264 rx_decode_opcode (unsigned long pc AU,
 265                   RX_Opcode_Decoded * rx,
 266                   int (* getbyte)(void *),
 267                   void * ptr)
 268 {
 269   LocalData lds, * ld = &lds;
 270   unsigned char op[20] = {0};
 271
 272   lds.rx = rx;
 273   lds.getbyte = getbyte;
 274   lds.ptr = ptr;
 275   lds.op = op;
 276
 277   memset (rx, 0, sizeof (*rx));
 278   BWL(LSIZE);
 279
 280
 281 /*----------------------------------------------------------------------*/
 282 /* MOV                                                                  */
 283
 284   GETBYTE ();
 285   switch (op[0] & 0xff)
 286   {
 287     case 0x00:
 288         {
 289           /** 0000 0000                 brk */
 290           if (trace)
 291             {
 292               printf ("\033[33m%s\033[0m  %02x\n",
 293                      "/** 0000 0000                     brk */",
 294                      op[0]);
 295             }
 296           SYNTAX("brk");
 297 #line 1025 "rx-decode.opc"
 298           ID(brk);
 299
 300         }
 301       break;
 302     case 0x01:
 303         {
 304           /** 0000 0001                 dbt */
 305           if (trace)
 306             {
 307               printf ("\033[33m%s\033[0m  %02x\n",
 308                      "/** 0000 0001                     dbt */",
 309                      op[0]);
 310             }
 311           SYNTAX("dbt");
 312 #line 1028 "rx-decode.opc"
 313           ID(dbt);
 314
 315         }
 316       break;
 317     case 0x02:
 318         {
 319           /** 0000 0010                 rts */
 320           if (trace)
 321             {
 322               printf ("\033[33m%s\033[0m  %02x\n",
 323                      "/** 0000 0010                     rts */",
 324                      op[0]);
 325             }
 326           SYNTAX("rts");
 327 #line 806 "rx-decode.opc"
 328           ID(rts);
 329
 330         /*----------------------------------------------------------------------*/
 331         /* NOP                                                          */
 332
 333         }
 334       break;
 335     case 0x03:
 336         {
 337           /** 0000 0011                 nop */
 338           if (trace)
 339             {
 340               printf ("\033[33m%s\033[0m  %02x\n",
 341                      "/** 0000 0011                     nop */",
 342                      op[0]);
 343             }
 344           SYNTAX("nop");
 345 #line 812 "rx-decode.opc"
 346           ID(nop);
 347
 348         /*----------------------------------------------------------------------*/
 349         /* STRING FUNCTIONS                                                     */
 350
 351         }
 352       break;
 353     case 0x04:
 354         {
 355           /** 0000 0100                 bra.a   %a0 */
 356           if (trace)
 357             {
 358               printf ("\033[33m%s\033[0m  %02x\n",
 359                      "/** 0000 0100                     bra.a   %a0 */",
 360                      op[0]);
 361             }
 362           SYNTAX("bra.a %a0");
 363 #line 784 "rx-decode.opc"
 364           ID(branch); DC(pc + IMMex(3));
 365
 366         }
 367       break;
 368     case 0x05:
 369         {
 370           /** 0000 0101                 bsr.a   %a0 */
 371           if (trace)
 372             {
 373               printf ("\033[33m%s\033[0m  %02x\n",
 374                      "/** 0000 0101                     bsr.a   %a0 */",
 375                      op[0]);
 376             }
 377           SYNTAX("bsr.a %a0");
 378 #line 800 "rx-decode.opc"
 379           ID(jsr); DC(pc + IMMex(3));
 380
 381         }
 382       break;
 383     case 0x06:
 384         GETBYTE ();
 385         switch (op[1] & 0xff)
 386         {
 387           case 0x00:
 388               GETBYTE ();
 389               switch (op[2] & 0x00)
 390               {
 391                 case 0x00:
 392                   op_semantics_1:
 393                     {
 394                       /** 0000 0110 mx00 00ss rsrc rdst                 sub     %2%S2, %1 */
 395 #line 542 "rx-decode.opc"
 396                       int mx AU = (op[1] >> 6) & 0x03;
 397 #line 542 "rx-decode.opc"
 398                       int ss AU = op[1] & 0x03;
 399 #line 542 "rx-decode.opc"
 400                       int rsrc AU = (op[2] >> 4) & 0x0f;
 401 #line 542 "rx-decode.opc"
 402                       int rdst AU = op[2] & 0x0f;
 403                       if (trace)
 404                         {
 405                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 406                                  "/** 0000 0110 mx00 00ss rsrc rdst                     sub     %2%S2, %1 */",
 407                                  op[0], op[1], op[2]);
 408                           printf ("  mx = 0x%x,", mx);
 409                           printf ("  ss = 0x%x,", ss);
 410                           printf ("  rsrc = 0x%x,", rsrc);
 411                           printf ("  rdst = 0x%x\n", rdst);
 412                         }
 413                       SYNTAX("sub       %2%S2, %1");
 414 #line 542 "rx-decode.opc"
 415                       ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
 416
 417                     }
 418                   break;
 419               }
 420             break;
 421           case 0x01:
 422               GETBYTE ();
 423               switch (op[2] & 0x00)
 424               {
 425                 case 0x00:
 426                   goto op_semantics_1;
 427                   break;
 428               }
 429             break;
 430           case 0x02:
 431               GETBYTE ();
 432               switch (op[2] & 0x00)
 433               {
 434                 case 0x00:
 435                   goto op_semantics_1;
 436                   break;
 437               }
 438             break;
 439           case 0x03:
 440               GETBYTE ();
 441               switch (op[2] & 0x00)
 442               {
 443                 case 0x00:
 444                   goto op_semantics_1;
 445                   break;
 446               }
 447             break;
 448           case 0x04:
 449               GETBYTE ();
 450               switch (op[2] & 0x00)
 451               {
 452                 case 0x00:
 453                   op_semantics_2:
 454                     {
 455                       /** 0000 0110 mx00 01ss rsrc rdst         cmp     %2%S2, %1 */
 456 #line 530 "rx-decode.opc"
 457                       int mx AU = (op[1] >> 6) & 0x03;
 458 #line 530 "rx-decode.opc"
 459                       int ss AU = op[1] & 0x03;
 460 #line 530 "rx-decode.opc"
 461                       int rsrc AU = (op[2] >> 4) & 0x0f;
 462 #line 530 "rx-decode.opc"
 463                       int rdst AU = op[2] & 0x0f;
 464                       if (trace)
 465                         {
 466                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 467                                  "/** 0000 0110 mx00 01ss rsrc rdst             cmp     %2%S2, %1 */",
 468                                  op[0], op[1], op[2]);
 469                           printf ("  mx = 0x%x,", mx);
 470                           printf ("  ss = 0x%x,", ss);
 471                           printf ("  rsrc = 0x%x,", rsrc);
 472                           printf ("  rdst = 0x%x\n", rdst);
 473                         }
 474                       SYNTAX("cmp       %2%S2, %1");
 475 #line 530 "rx-decode.opc"
 476                       ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
 477
 478                     /*----------------------------------------------------------------------*/
 479                     /* SUB                                                                      */
 480
 481                     }
 482                   break;
 483               }
 484             break;
 485           case 0x05:
 486               GETBYTE ();
 487               switch (op[2] & 0x00)
 488               {
 489                 case 0x00:
 490                   goto op_semantics_2;
 491                   break;
 492               }
 493             break;
 494           case 0x06:
 495               GETBYTE ();
 496               switch (op[2] & 0x00)
 497               {
 498                 case 0x00:
 499                   goto op_semantics_2;
 500                   break;
 501               }
 502             break;
 503           case 0x07:
 504               GETBYTE ();
 505               switch (op[2] & 0x00)
 506               {
 507                 case 0x00:
 508                   goto op_semantics_2;
 509                   break;
 510               }
 511             break;
 512           case 0x08:
 513               GETBYTE ();
 514               switch (op[2] & 0x00)
 515               {
 516                 case 0x00:
 517                   op_semantics_3:
 518                     {
 519                       /** 0000 0110 mx00 10ss rsrc rdst add     %1%S1, %0 */
 520 #line 506 "rx-decode.opc"
 521                       int mx AU = (op[1] >> 6) & 0x03;
 522 #line 506 "rx-decode.opc"
 523                       int ss AU = op[1] & 0x03;
 524 #line 506 "rx-decode.opc"
 525                       int rsrc AU = (op[2] >> 4) & 0x0f;
 526 #line 506 "rx-decode.opc"
 527                       int rdst AU = op[2] & 0x0f;
 528                       if (trace)
 529                         {
 530                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 531                                  "/** 0000 0110 mx00 10ss rsrc rdst     add     %1%S1, %0 */",
 532                                  op[0], op[1], op[2]);
 533                           printf ("  mx = 0x%x,", mx);
 534                           printf ("  ss = 0x%x,", ss);
 535                           printf ("  rsrc = 0x%x,", rsrc);
 536                           printf ("  rdst = 0x%x\n", rdst);
 537                         }
 538                       SYNTAX("add       %1%S1, %0");
 539 #line 506 "rx-decode.opc"
 540                       ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
 541
 542                     }
 543                   break;
 544               }
 545             break;
 546           case 0x09:
 547               GETBYTE ();
 548               switch (op[2] & 0x00)
 549               {
 550                 case 0x00:
 551                   goto op_semantics_3;
 552                   break;
 553               }
 554             break;
 555           case 0x0a:
 556               GETBYTE ();
 557               switch (op[2] & 0x00)
 558               {
 559                 case 0x00:
 560                   goto op_semantics_3;
 561                   break;
 562               }
 563             break;
 564           case 0x0b:
 565               GETBYTE ();
 566               switch (op[2] & 0x00)
 567               {
 568                 case 0x00:
 569                   goto op_semantics_3;
 570                   break;
 571               }
 572             break;
 573           case 0x0c:
 574               GETBYTE ();
 575               switch (op[2] & 0x00)
 576               {
 577                 case 0x00:
 578                   op_semantics_4:
 579                     {
 580                       /** 0000 0110 mx00 11ss rsrc rdst mul     %1%S1, %0 */
 581 #line 649 "rx-decode.opc"
 582                       int mx AU = (op[1] >> 6) & 0x03;
 583 #line 649 "rx-decode.opc"
 584                       int ss AU = op[1] & 0x03;
 585 #line 649 "rx-decode.opc"
 586                       int rsrc AU = (op[2] >> 4) & 0x0f;
 587 #line 649 "rx-decode.opc"
 588                       int rdst AU = op[2] & 0x0f;
 589                       if (trace)
 590                         {
 591                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 592                                  "/** 0000 0110 mx00 11ss rsrc rdst     mul     %1%S1, %0 */",
 593                                  op[0], op[1], op[2]);
 594                           printf ("  mx = 0x%x,", mx);
 595                           printf ("  ss = 0x%x,", ss);
 596                           printf ("  rsrc = 0x%x,", rsrc);
 597                           printf ("  rdst = 0x%x\n", rdst);
 598                         }
 599                       SYNTAX("mul       %1%S1, %0");
 600 #line 649 "rx-decode.opc"
 601                       ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
 602
 603                     }
 604                   break;
 605               }
 606             break;
 607           case 0x0d:
 608               GETBYTE ();
 609               switch (op[2] & 0x00)
 610               {
 611                 case 0x00:
 612                   goto op_semantics_4;
 613                   break;
 614               }
 615             break;
 616           case 0x0e:
 617               GETBYTE ();
 618               switch (op[2] & 0x00)
 619               {
 620                 case 0x00:
 621                   goto op_semantics_4;
 622                   break;
 623               }
 624             break;
 625           case 0x0f:
 626               GETBYTE ();
 627               switch (op[2] & 0x00)
 628               {
 629                 case 0x00:
 630                   goto op_semantics_4;
 631                   break;
 632               }
 633             break;
 634           case 0x10:
 635               GETBYTE ();
 636               switch (op[2] & 0x00)
 637               {
 638                 case 0x00:
 639                   op_semantics_5:
 640                     {
 641                       /** 0000 0110 mx01 00ss rsrc rdst and     %1%S1, %0 */
 642 #line 419 "rx-decode.opc"
 643                       int mx AU = (op[1] >> 6) & 0x03;
 644 #line 419 "rx-decode.opc"
 645                       int ss AU = op[1] & 0x03;
 646 #line 419 "rx-decode.opc"
 647                       int rsrc AU = (op[2] >> 4) & 0x0f;
 648 #line 419 "rx-decode.opc"
 649                       int rdst AU = op[2] & 0x0f;
 650                       if (trace)
 651                         {
 652                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 653                                  "/** 0000 0110 mx01 00ss rsrc rdst     and     %1%S1, %0 */",
 654                                  op[0], op[1], op[2]);
 655                           printf ("  mx = 0x%x,", mx);
 656                           printf ("  ss = 0x%x,", ss);
 657                           printf ("  rsrc = 0x%x,", rsrc);
 658                           printf ("  rdst = 0x%x\n", rdst);
 659                         }
 660                       SYNTAX("and       %1%S1, %0");
 661 #line 419 "rx-decode.opc"
 662                       ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
 663
 664                     }
 665                   break;
 666               }
 667             break;
 668           case 0x11:
 669               GETBYTE ();
 670               switch (op[2] & 0x00)
 671               {
 672                 case 0x00:
 673                   goto op_semantics_5;
 674                   break;
 675               }
 676             break;
 677           case 0x12:
 678               GETBYTE ();
 679               switch (op[2] & 0x00)
 680               {
 681                 case 0x00:
 682                   goto op_semantics_5;
 683                   break;
 684               }
 685             break;
 686           case 0x13:
 687               GETBYTE ();
 688               switch (op[2] & 0x00)
 689               {
 690                 case 0x00:
 691                   goto op_semantics_5;
 692                   break;
 693               }
 694             break;
 695           case 0x14:
 696               GETBYTE ();
 697               switch (op[2] & 0x00)
 698               {
 699                 case 0x00:
 700                   op_semantics_6:
 701                     {
 702                       /** 0000 0110 mx01 01ss rsrc rdst                 or      %1%S1, %0 */
 703 #line 437 "rx-decode.opc"
 704                       int mx AU = (op[1] >> 6) & 0x03;
 705 #line 437 "rx-decode.opc"
 706                       int ss AU = op[1] & 0x03;
 707 #line 437 "rx-decode.opc"
 708                       int rsrc AU = (op[2] >> 4) & 0x0f;
 709 #line 437 "rx-decode.opc"
 710                       int rdst AU = op[2] & 0x0f;
 711                       if (trace)
 712                         {
 713                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 714                                  "/** 0000 0110 mx01 01ss rsrc rdst                     or      %1%S1, %0 */",
 715                                  op[0], op[1], op[2]);
 716                           printf ("  mx = 0x%x,", mx);
 717                           printf ("  ss = 0x%x,", ss);
 718                           printf ("  rsrc = 0x%x,", rsrc);
 719                           printf ("  rdst = 0x%x\n", rdst);
 720                         }
 721                       SYNTAX("or        %1%S1, %0");
 722 #line 437 "rx-decode.opc"
 723                       ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
 724
 725                     }
 726                   break;
 727               }
 728             break;
 729           case 0x15:
 730               GETBYTE ();
 731               switch (op[2] & 0x00)
 732               {
 733                 case 0x00:
 734                   goto op_semantics_6;
 735                   break;
 736               }
 737             break;
 738           case 0x16:
 739               GETBYTE ();
 740               switch (op[2] & 0x00)
 741               {
 742                 case 0x00:
 743                   goto op_semantics_6;
 744                   break;
 745               }
 746             break;
 747           case 0x17:
 748               GETBYTE ();
 749               switch (op[2] & 0x00)
 750               {
 751                 case 0x00:
 752                   goto op_semantics_6;
 753                   break;
 754               }
 755             break;
 756           case 0x20:
 757               GETBYTE ();
 758               switch (op[2] & 0xff)
 759               {
 760                 case 0x00:
 761                     GETBYTE ();
 762                     switch (op[3] & 0x00)
 763                     {
 764                       case 0x00:
 765                         op_semantics_7:
 766                           {
 767                             /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb     %1%S1, %0 */
 768 #line 555 "rx-decode.opc"
 769                             int mx AU = (op[1] >> 6) & 0x03;
 770 #line 555 "rx-decode.opc"
 771                             int sp AU = op[1] & 0x03;
 772 #line 555 "rx-decode.opc"
 773                             int rsrc AU = (op[3] >> 4) & 0x0f;
 774 #line 555 "rx-decode.opc"
 775                             int rdst AU = op[3] & 0x0f;
 776                             if (trace)
 777                               {
 778                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 779                                        "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst     sbb     %1%S1, %0 */",
 780                                        op[0], op[1], op[2], op[3]);
 781                                 printf ("  mx = 0x%x,", mx);
 782                                 printf ("  sp = 0x%x,", sp);
 783                                 printf ("  rsrc = 0x%x,", rsrc);
 784                                 printf ("  rdst = 0x%x\n", rdst);
 785                               }
 786                             SYNTAX("sbb %1%S1, %0");
 787 #line 555 "rx-decode.opc"
 788                             ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
 789
 790                           /*----------------------------------------------------------------------*/
 791                           /* ABS                                                                        */
 792
 793                           }
 794                         break;
 795                     }
 796                   break;
 797                 case 0x04:
 798                     GETBYTE ();
 799                     switch (op[3] & 0x00)
 800                     {
 801                       case 0x00:
 802                         op_semantics_8:
 803                           {
 804                             /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max     %1%S1, %0 */
 805 #line 594 "rx-decode.opc"
 806                             int mx AU = (op[1] >> 6) & 0x03;
 807 #line 594 "rx-decode.opc"
 808                             int ss AU = op[1] & 0x03;
 809 #line 594 "rx-decode.opc"
 810                             int rsrc AU = (op[3] >> 4) & 0x0f;
 811 #line 594 "rx-decode.opc"
 812                             int rdst AU = op[3] & 0x0f;
 813                             if (trace)
 814                               {
 815                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 816                                        "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst     max     %1%S1, %0 */",
 817                                        op[0], op[1], op[2], op[3]);
 818                                 printf ("  mx = 0x%x,", mx);
 819                                 printf ("  ss = 0x%x,", ss);
 820                                 printf ("  rsrc = 0x%x,", rsrc);
 821                                 printf ("  rdst = 0x%x\n", rdst);
 822                               }
 823                             SYNTAX("max %1%S1, %0");
 824 #line 594 "rx-decode.opc"
 825                             ID(max); SPm(ss, rsrc, mx); DR(rdst);
 826
 827                           /*----------------------------------------------------------------------*/
 828                           /* MIN                                                                        */
 829
 830                           }
 831                         break;
 832                     }
 833                   break;
 834                 case 0x05:
 835                     GETBYTE ();
 836                     switch (op[3] & 0x00)
 837                     {
 838                       case 0x00:
 839                         op_semantics_9:
 840                           {
 841                             /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min     %1%S1, %0 */
 842 #line 606 "rx-decode.opc"
 843                             int mx AU = (op[1] >> 6) & 0x03;
 844 #line 606 "rx-decode.opc"
 845                             int ss AU = op[1] & 0x03;
 846 #line 606 "rx-decode.opc"
 847                             int rsrc AU = (op[3] >> 4) & 0x0f;
 848 #line 606 "rx-decode.opc"
 849                             int rdst AU = op[3] & 0x0f;
 850                             if (trace)
 851                               {
 852                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 853                                        "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst     min     %1%S1, %0 */",
 854                                        op[0], op[1], op[2], op[3]);
 855                                 printf ("  mx = 0x%x,", mx);
 856                                 printf ("  ss = 0x%x,", ss);
 857                                 printf ("  rsrc = 0x%x,", rsrc);
 858                                 printf ("  rdst = 0x%x\n", rdst);
 859                               }
 860                             SYNTAX("min %1%S1, %0");
 861 #line 606 "rx-decode.opc"
 862                             ID(min); SPm(ss, rsrc, mx); DR(rdst);
 863
 864                           /*----------------------------------------------------------------------*/
 865                           /* MUL                                                                        */
 866
 867                           }
 868                         break;
 869                     }
 870                   break;
 871                 case 0x06:
 872                     GETBYTE ();
 873                     switch (op[3] & 0x00)
 874                     {
 875                       case 0x00:
 876                         op_semantics_10:
 877                           {
 878                             /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul    %1%S1, %0 */
 879 #line 664 "rx-decode.opc"
 880                             int mx AU = (op[1] >> 6) & 0x03;
 881 #line 664 "rx-decode.opc"
 882                             int ss AU = op[1] & 0x03;
 883 #line 664 "rx-decode.opc"
 884                             int rsrc AU = (op[3] >> 4) & 0x0f;
 885 #line 664 "rx-decode.opc"
 886                             int rdst AU = op[3] & 0x0f;
 887                             if (trace)
 888                               {
 889                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 890                                        "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst     emul    %1%S1, %0 */",
 891                                        op[0], op[1], op[2], op[3]);
 892                                 printf ("  mx = 0x%x,", mx);
 893                                 printf ("  ss = 0x%x,", ss);
 894                                 printf ("  rsrc = 0x%x,", rsrc);
 895                                 printf ("  rdst = 0x%x\n", rdst);
 896                               }
 897                             SYNTAX("emul        %1%S1, %0");
 898 #line 664 "rx-decode.opc"
 899                             ID(emul); SPm(ss, rsrc, mx); DR(rdst);
 900
 901                           /*----------------------------------------------------------------------*/
 902                           /* EMULU                                                                      */
 903
 904                           }
 905                         break;
 906                     }
 907                   break;
 908                 case 0x07:
 909                     GETBYTE ();
 910                     switch (op[3] & 0x00)
 911                     {
 912                       case 0x00:
 913                         op_semantics_11:
 914                           {
 915                             /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu   %1%S1, %0 */
 916 #line 676 "rx-decode.opc"
 917                             int mx AU = (op[1] >> 6) & 0x03;
 918 #line 676 "rx-decode.opc"
 919                             int ss AU = op[1] & 0x03;
 920 #line 676 "rx-decode.opc"
 921                             int rsrc AU = (op[3] >> 4) & 0x0f;
 922 #line 676 "rx-decode.opc"
 923                             int rdst AU = op[3] & 0x0f;
 924                             if (trace)
 925                               {
 926                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 927                                        "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst     emulu   %1%S1, %0 */",
 928                                        op[0], op[1], op[2], op[3]);
 929                                 printf ("  mx = 0x%x,", mx);
 930                                 printf ("  ss = 0x%x,", ss);
 931                                 printf ("  rsrc = 0x%x,", rsrc);
 932                                 printf ("  rdst = 0x%x\n", rdst);
 933                               }
 934                             SYNTAX("emulu       %1%S1, %0");
 935 #line 676 "rx-decode.opc"
 936                             ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
 937
 938                           /*----------------------------------------------------------------------*/
 939                           /* DIV                                                                        */
 940
 941                           }
 942                         break;
 943                     }
 944                   break;
 945                 case 0x08:
 946                     GETBYTE ();
 947                     switch (op[3] & 0x00)
 948                     {
 949                       case 0x00:
 950                         op_semantics_12:
 951                           {
 952                             /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div     %1%S1, %0 */
 953 #line 688 "rx-decode.opc"
 954                             int mx AU = (op[1] >> 6) & 0x03;
 955 #line 688 "rx-decode.opc"
 956                             int ss AU = op[1] & 0x03;
 957 #line 688 "rx-decode.opc"
 958                             int rsrc AU = (op[3] >> 4) & 0x0f;
 959 #line 688 "rx-decode.opc"
 960                             int rdst AU = op[3] & 0x0f;
 961                             if (trace)
 962                               {
 963                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 964                                        "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst     div     %1%S1, %0 */",
 965                                        op[0], op[1], op[2], op[3]);
 966                                 printf ("  mx = 0x%x,", mx);
 967                                 printf ("  ss = 0x%x,", ss);
 968                                 printf ("  rsrc = 0x%x,", rsrc);
 969                                 printf ("  rdst = 0x%x\n", rdst);
 970                               }
 971                             SYNTAX("div %1%S1, %0");
 972 #line 688 "rx-decode.opc"
 973                             ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
 974
 975                           /*----------------------------------------------------------------------*/
 976                           /* DIVU                                                                       */
 977
 978                           }
 979                         break;
 980                     }
 981                   break;
 982                 case 0x09:
 983                     GETBYTE ();
 984                     switch (op[3] & 0x00)
 985                     {
 986                       case 0x00:
 987                         op_semantics_13:
 988                           {
 989                             /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu    %1%S1, %0 */
 990 #line 700 "rx-decode.opc"
 991                             int mx AU = (op[1] >> 6) & 0x03;
 992 #line 700 "rx-decode.opc"
 993                             int ss AU = op[1] & 0x03;
 994 #line 700 "rx-decode.opc"
 995                             int rsrc AU = (op[3] >> 4) & 0x0f;
 996 #line 700 "rx-decode.opc"
 997                             int rdst AU = op[3] & 0x0f;
 998                             if (trace)
 999                               {
1000                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1001                                        "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst     divu    %1%S1, %0 */",
1002                                        op[0], op[1], op[2], op[3]);
1003                                 printf ("  mx = 0x%x,", mx);
1004                                 printf ("  ss = 0x%x,", ss);
1005                                 printf ("  rsrc = 0x%x,", rsrc);
1006                                 printf ("  rdst = 0x%x\n", rdst);
1007                               }
1008                             SYNTAX("divu        %1%S1, %0");
1009 #line 700 "rx-decode.opc"
1010                             ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1011
1012                           /*----------------------------------------------------------------------*/
1013                           /* SHIFT                                                              */
1014
1015                           }
1016                         break;
1017                     }
1018                   break;
1019                 case 0x0c:
1020                     GETBYTE ();
1021                     switch (op[3] & 0x00)
1022                     {
1023                       case 0x00:
1024                         op_semantics_14:
1025                           {
1026                             /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst     %1%S1, %2 */
1027 #line 473 "rx-decode.opc"
1028                             int mx AU = (op[1] >> 6) & 0x03;
1029 #line 473 "rx-decode.opc"
1030                             int ss AU = op[1] & 0x03;
1031 #line 473 "rx-decode.opc"
1032                             int rsrc AU = (op[3] >> 4) & 0x0f;
1033 #line 473 "rx-decode.opc"
1034                             int rdst AU = op[3] & 0x0f;
1035                             if (trace)
1036                               {
1037                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1038                                        "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst     tst     %1%S1, %2 */",
1039                                        op[0], op[1], op[2], op[3]);
1040                                 printf ("  mx = 0x%x,", mx);
1041                                 printf ("  ss = 0x%x,", ss);
1042                                 printf ("  rsrc = 0x%x,", rsrc);
1043                                 printf ("  rdst = 0x%x\n", rdst);
1044                               }
1045                             SYNTAX("tst %1%S1, %2");
1046 #line 473 "rx-decode.opc"
1047                             ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1048
1049                           /*----------------------------------------------------------------------*/
1050                           /* NEG                                                                        */
1051
1052                           }
1053                         break;
1054                     }
1055                   break;
1056                 case 0x0d:
1057                     GETBYTE ();
1058                     switch (op[3] & 0x00)
1059                     {
1060                       case 0x00:
1061                         op_semantics_15:
1062                           {
1063                             /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor     %1%S1, %0 */
1064 #line 452 "rx-decode.opc"
1065                             int mx AU = (op[1] >> 6) & 0x03;
1066 #line 452 "rx-decode.opc"
1067                             int ss AU = op[1] & 0x03;
1068 #line 452 "rx-decode.opc"
1069                             int rsrc AU = (op[3] >> 4) & 0x0f;
1070 #line 452 "rx-decode.opc"
1071                             int rdst AU = op[3] & 0x0f;
1072                             if (trace)
1073                               {
1074                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1075                                        "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst     xor     %1%S1, %0 */",
1076                                        op[0], op[1], op[2], op[3]);
1077                                 printf ("  mx = 0x%x,", mx);
1078                                 printf ("  ss = 0x%x,", ss);
1079                                 printf ("  rsrc = 0x%x,", rsrc);
1080                                 printf ("  rdst = 0x%x\n", rdst);
1081                               }
1082                             SYNTAX("xor %1%S1, %0");
1083 #line 452 "rx-decode.opc"
1084                             ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1085
1086                           /*----------------------------------------------------------------------*/
1087                           /* NOT                                                                        */
1088
1089                           }
1090                         break;
1091                     }
1092                   break;
1093                 case 0x10:
1094                     GETBYTE ();
1095                     switch (op[3] & 0x00)
1096                     {
1097                       case 0x00:
1098                         op_semantics_16:
1099                           {
1100                             /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg    %1%S1, %0 */
1101 #line 386 "rx-decode.opc"
1102                             int mx AU = (op[1] >> 6) & 0x03;
1103 #line 386 "rx-decode.opc"
1104                             int ss AU = op[1] & 0x03;
1105 #line 386 "rx-decode.opc"
1106                             int rsrc AU = (op[3] >> 4) & 0x0f;
1107 #line 386 "rx-decode.opc"
1108                             int rdst AU = op[3] & 0x0f;
1109                             if (trace)
1110                               {
1111                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1112                                        "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst     xchg    %1%S1, %0 */",
1113                                        op[0], op[1], op[2], op[3]);
1114                                 printf ("  mx = 0x%x,", mx);
1115                                 printf ("  ss = 0x%x,", ss);
1116                                 printf ("  rsrc = 0x%x,", rsrc);
1117                                 printf ("  rdst = 0x%x\n", rdst);
1118                               }
1119                             SYNTAX("xchg        %1%S1, %0");
1120 #line 386 "rx-decode.opc"
1121                             ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1122
1123                           /*----------------------------------------------------------------------*/
1124                           /* STZ/STNZ                                                           */
1125
1126                           }
1127                         break;
1128                     }
1129                   break;
1130                 case 0x11:
1131                     GETBYTE ();
1132                     switch (op[3] & 0x00)
1133                     {
1134                       case 0x00:
1135                         op_semantics_17:
1136                           {
1137                             /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof    %1%S1, %0 */
1138 #line 929 "rx-decode.opc"
1139                             int mx AU = (op[1] >> 6) & 0x03;
1140 #line 929 "rx-decode.opc"
1141                             int sd AU = op[1] & 0x03;
1142 #line 929 "rx-decode.opc"
1143                             int rsrc AU = (op[3] >> 4) & 0x0f;
1144 #line 929 "rx-decode.opc"
1145                             int rdst AU = op[3] & 0x0f;
1146                             if (trace)
1147                               {
1148                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1149                                        "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst     itof    %1%S1, %0 */",
1150                                        op[0], op[1], op[2], op[3]);
1151                                 printf ("  mx = 0x%x,", mx);
1152                                 printf ("  sd = 0x%x,", sd);
1153                                 printf ("  rsrc = 0x%x,", rsrc);
1154                                 printf ("  rdst = 0x%x\n", rdst);
1155                               }
1156                             SYNTAX("itof        %1%S1, %0");
1157 #line 929 "rx-decode.opc"
1158                             ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1159
1160                           /*----------------------------------------------------------------------*/
1161                           /* BIT OPS                                                            */
1162
1163                           }
1164                         break;
1165                     }
1166                   break;
1167                 case 0x15:
1168                     GETBYTE ();
1169                     switch (op[3] & 0x00)
1170                     {
1171                       case 0x00:
1172                         op_semantics_18:
1173                           {
1174                             /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof    %1%S1, %0 */
1175 #line 1115 "rx-decode.opc"
1176                             int mx AU = (op[1] >> 6) & 0x03;
1177 #line 1115 "rx-decode.opc"
1178                             int sd AU = op[1] & 0x03;
1179 #line 1115 "rx-decode.opc"
1180                             int rsrc AU = (op[3] >> 4) & 0x0f;
1181 #line 1115 "rx-decode.opc"
1182                             int rdst AU = op[3] & 0x0f;
1183                             if (trace)
1184                               {
1185                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1186                                        "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst     utof    %1%S1, %0 */",
1187                                        op[0], op[1], op[2], op[3]);
1188                                 printf ("  mx = 0x%x,", mx);
1189                                 printf ("  sd = 0x%x,", sd);
1190                                 printf ("  rsrc = 0x%x,", rsrc);
1191                                 printf ("  rdst = 0x%x\n", rdst);
1192                               }
1193                             SYNTAX("utof        %1%S1, %0");
1194 #line 1115 "rx-decode.opc"
1195                             ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1196
1197                           }
1198                         break;
1199                     }
1200                   break;
1201                 default: UNSUPPORTED(); break;
1202               }
1203             break;
1204           case 0x21:
1205               GETBYTE ();
1206               switch (op[2] & 0xff)
1207               {
1208                 case 0x00:
1209                     GETBYTE ();
1210                     switch (op[3] & 0x00)
1211                     {
1212                       case 0x00:
1213                         goto op_semantics_7;
1214                         break;
1215                     }
1216                   break;
1217                 case 0x04:
1218                     GETBYTE ();
1219                     switch (op[3] & 0x00)
1220                     {
1221                       case 0x00:
1222                         goto op_semantics_8;
1223                         break;
1224                     }
1225                   break;
1226                 case 0x05:
1227                     GETBYTE ();
1228                     switch (op[3] & 0x00)
1229                     {
1230                       case 0x00:
1231                         goto op_semantics_9;
1232                         break;
1233                     }
1234                   break;
1235                 case 0x06:
1236                     GETBYTE ();
1237                     switch (op[3] & 0x00)
1238                     {
1239                       case 0x00:
1240                         goto op_semantics_10;
1241                         break;
1242                     }
1243                   break;
1244                 case 0x07:
1245                     GETBYTE ();
1246                     switch (op[3] & 0x00)
1247                     {
1248                       case 0x00:
1249                         goto op_semantics_11;
1250                         break;
1251                     }
1252                   break;
1253                 case 0x08:
1254                     GETBYTE ();
1255                     switch (op[3] & 0x00)
1256                     {
1257                       case 0x00:
1258                         goto op_semantics_12;
1259                         break;
1260                     }
1261                   break;
1262                 case 0x09:
1263                     GETBYTE ();
1264                     switch (op[3] & 0x00)
1265                     {
1266                       case 0x00:
1267                         goto op_semantics_13;
1268                         break;
1269                     }
1270                   break;
1271                 case 0x0c:
1272                     GETBYTE ();
1273                     switch (op[3] & 0x00)
1274                     {
1275                       case 0x00:
1276                         goto op_semantics_14;
1277                         break;
1278                     }
1279                   break;
1280                 case 0x0d:
1281                     GETBYTE ();
1282                     switch (op[3] & 0x00)
1283                     {
1284                       case 0x00:
1285                         goto op_semantics_15;
1286                         break;
1287                     }
1288                   break;
1289                 case 0x10:
1290                     GETBYTE ();
1291                     switch (op[3] & 0x00)
1292                     {
1293                       case 0x00:
1294                         goto op_semantics_16;
1295                         break;
1296                     }
1297                   break;
1298                 case 0x11:
1299                     GETBYTE ();
1300                     switch (op[3] & 0x00)
1301                     {
1302                       case 0x00:
1303                         goto op_semantics_17;
1304                         break;
1305                     }
1306                   break;
1307                 case 0x15:
1308                     GETBYTE ();
1309                     switch (op[3] & 0x00)
1310                     {
1311                       case 0x00:
1312                         goto op_semantics_18;
1313                         break;
1314                     }
1315                   break;
1316                 default: UNSUPPORTED(); break;
1317               }
1318             break;
1319           case 0x22:
1320               GETBYTE ();
1321               switch (op[2] & 0xff)
1322               {
1323                 case 0x00:
1324                     GETBYTE ();
1325                     switch (op[3] & 0x00)
1326                     {
1327                       case 0x00:
1328                         goto op_semantics_7;
1329                         break;
1330                     }
1331                   break;
1332                 case 0x04:
1333                     GETBYTE ();
1334                     switch (op[3] & 0x00)
1335                     {
1336                       case 0x00:
1337                         goto op_semantics_8;
1338                         break;
1339                     }
1340                   break;
1341                 case 0x05:
1342                     GETBYTE ();
1343                     switch (op[3] & 0x00)
1344                     {
1345                       case 0x00:
1346                         goto op_semantics_9;
1347                         break;
1348                     }
1349                   break;
1350                 case 0x06:
1351                     GETBYTE ();
1352                     switch (op[3] & 0x00)
1353                     {
1354                       case 0x00:
1355                         goto op_semantics_10;
1356                         break;
1357                     }
1358                   break;
1359                 case 0x07:
1360                     GETBYTE ();
1361                     switch (op[3] & 0x00)
1362                     {
1363                       case 0x00:
1364                         goto op_semantics_11;
1365                         break;
1366                     }
1367                   break;
1368                 case 0x08:
1369                     GETBYTE ();
1370                     switch (op[3] & 0x00)
1371                     {
1372                       case 0x00:
1373                         goto op_semantics_12;
1374                         break;
1375                     }
1376                   break;
1377                 case 0x09:
1378                     GETBYTE ();
1379                     switch (op[3] & 0x00)
1380                     {
1381                       case 0x00:
1382                         goto op_semantics_13;
1383                         break;
1384                     }
1385                   break;
1386                 case 0x0c:
1387                     GETBYTE ();
1388                     switch (op[3] & 0x00)
1389                     {
1390                       case 0x00:
1391                         goto op_semantics_14;
1392                         break;
1393                     }
1394                   break;
1395                 case 0x0d:
1396                     GETBYTE ();
1397                     switch (op[3] & 0x00)
1398                     {
1399                       case 0x00:
1400                         goto op_semantics_15;
1401                         break;
1402                     }
1403                   break;
1404                 case 0x10:
1405                     GETBYTE ();
1406                     switch (op[3] & 0x00)
1407                     {
1408                       case 0x00:
1409                         goto op_semantics_16;
1410                         break;
1411                     }
1412                   break;
1413                 case 0x11:
1414                     GETBYTE ();
1415                     switch (op[3] & 0x00)
1416                     {
1417                       case 0x00:
1418                         goto op_semantics_17;
1419                         break;
1420                     }
1421                   break;
1422                 case 0x15:
1423                     GETBYTE ();
1424                     switch (op[3] & 0x00)
1425                     {
1426                       case 0x00:
1427                         goto op_semantics_18;
1428                         break;
1429                     }
1430                   break;
1431                 default: UNSUPPORTED(); break;
1432               }
1433             break;
1434           case 0x23:
1435               GETBYTE ();
1436               switch (op[2] & 0xff)
1437               {
1438                 case 0x00:
1439                     GETBYTE ();
1440                     switch (op[3] & 0x00)
1441                     {
1442                       case 0x00:
1443                         goto op_semantics_7;
1444                         break;
1445                     }
1446                   break;
1447                 case 0x04:
1448                     GETBYTE ();
1449                     switch (op[3] & 0x00)
1450                     {
1451                       case 0x00:
1452                         goto op_semantics_8;
1453                         break;
1454                     }
1455                   break;
1456                 case 0x05:
1457                     GETBYTE ();
1458                     switch (op[3] & 0x00)
1459                     {
1460                       case 0x00:
1461                         goto op_semantics_9;
1462                         break;
1463                     }
1464                   break;
1465                 case 0x06:
1466                     GETBYTE ();
1467                     switch (op[3] & 0x00)
1468                     {
1469                       case 0x00:
1470                         goto op_semantics_10;
1471                         break;
1472                     }
1473                   break;
1474                 case 0x07:
1475                     GETBYTE ();
1476                     switch (op[3] & 0x00)
1477                     {
1478                       case 0x00:
1479                         goto op_semantics_11;
1480                         break;
1481                     }
1482                   break;
1483                 case 0x08:
1484                     GETBYTE ();
1485                     switch (op[3] & 0x00)
1486                     {
1487                       case 0x00:
1488                         goto op_semantics_12;
1489                         break;
1490                     }
1491                   break;
1492                 case 0x09:
1493                     GETBYTE ();
1494                     switch (op[3] & 0x00)
1495                     {
1496                       case 0x00:
1497                         goto op_semantics_13;
1498                         break;
1499                     }
1500                   break;
1501                 case 0x0c:
1502                     GETBYTE ();
1503                     switch (op[3] & 0x00)
1504                     {
1505                       case 0x00:
1506                         goto op_semantics_14;
1507                         break;
1508                     }
1509                   break;
1510                 case 0x0d:
1511                     GETBYTE ();
1512                     switch (op[3] & 0x00)
1513                     {
1514                       case 0x00:
1515                         goto op_semantics_15;
1516                         break;
1517                     }
1518                   break;
1519                 case 0x10:
1520                     GETBYTE ();
1521                     switch (op[3] & 0x00)
1522                     {
1523                       case 0x00:
1524                         goto op_semantics_16;
1525                         break;
1526                     }
1527                   break;
1528                 case 0x11:
1529                     GETBYTE ();
1530                     switch (op[3] & 0x00)
1531                     {
1532                       case 0x00:
1533                         goto op_semantics_17;
1534                         break;
1535                     }
1536                   break;
1537                 case 0x15:
1538                     GETBYTE ();
1539                     switch (op[3] & 0x00)
1540                     {
1541                       case 0x00:
1542                         goto op_semantics_18;
1543                         break;
1544                     }
1545                   break;
1546                 default: UNSUPPORTED(); break;
1547               }
1548             break;
1549           case 0x40:
1550               GETBYTE ();
1551               switch (op[2] & 0x00)
1552               {
1553                 case 0x00:
1554                   goto op_semantics_1;
1555                   break;
1556               }
1557             break;
1558           case 0x41:
1559               GETBYTE ();
1560               switch (op[2] & 0x00)
1561               {
1562                 case 0x00:
1563                   goto op_semantics_1;
1564                   break;
1565               }
1566             break;
1567           case 0x42:
1568               GETBYTE ();
1569               switch (op[2] & 0x00)
1570               {
1571                 case 0x00:
1572                   goto op_semantics_1;
1573                   break;
1574               }
1575             break;
1576           case 0x43:
1577               GETBYTE ();
1578               switch (op[2] & 0x00)
1579               {
1580                 case 0x00:
1581                   goto op_semantics_1;
1582                   break;
1583               }
1584             break;
1585           case 0x44:
1586               GETBYTE ();
1587               switch (op[2] & 0x00)
1588               {
1589                 case 0x00:
1590                   goto op_semantics_2;
1591                   break;
1592               }
1593             break;
1594           case 0x45:
1595               GETBYTE ();
1596               switch (op[2] & 0x00)
1597               {
1598                 case 0x00:
1599                   goto op_semantics_2;
1600                   break;
1601               }
1602             break;
1603           case 0x46:
1604               GETBYTE ();
1605               switch (op[2] & 0x00)
1606               {
1607                 case 0x00:
1608                   goto op_semantics_2;
1609                   break;
1610               }
1611             break;
1612           case 0x47:
1613               GETBYTE ();
1614               switch (op[2] & 0x00)
1615               {
1616                 case 0x00:
1617                   goto op_semantics_2;
1618                   break;
1619               }
1620             break;
1621           case 0x48:
1622               GETBYTE ();
1623               switch (op[2] & 0x00)
1624               {
1625                 case 0x00:
1626                   goto op_semantics_3;
1627                   break;
1628               }
1629             break;
1630           case 0x49:
1631               GETBYTE ();
1632               switch (op[2] & 0x00)
1633               {
1634                 case 0x00:
1635                   goto op_semantics_3;
1636                   break;
1637               }
1638             break;
1639           case 0x4a:
1640               GETBYTE ();
1641               switch (op[2] & 0x00)
1642               {
1643                 case 0x00:
1644                   goto op_semantics_3;
1645                   break;
1646               }
1647             break;
1648           case 0x4b:
1649               GETBYTE ();
1650               switch (op[2] & 0x00)
1651               {
1652                 case 0x00:
1653                   goto op_semantics_3;
1654                   break;
1655               }
1656             break;
1657           case 0x4c:
1658               GETBYTE ();
1659               switch (op[2] & 0x00)
1660               {
1661                 case 0x00:
1662                   goto op_semantics_4;
1663                   break;
1664               }
1665             break;
1666           case 0x4d:
1667               GETBYTE ();
1668               switch (op[2] & 0x00)
1669               {
1670                 case 0x00:
1671                   goto op_semantics_4;
1672                   break;
1673               }
1674             break;
1675           case 0x4e:
1676               GETBYTE ();
1677               switch (op[2] & 0x00)
1678               {
1679                 case 0x00:
1680                   goto op_semantics_4;
1681                   break;
1682               }
1683             break;
1684           case 0x4f:
1685               GETBYTE ();
1686               switch (op[2] & 0x00)
1687               {
1688                 case 0x00:
1689                   goto op_semantics_4;
1690                   break;
1691               }
1692             break;
1693           case 0x50:
1694               GETBYTE ();
1695               switch (op[2] & 0x00)
1696               {
1697                 case 0x00:
1698                   goto op_semantics_5;
1699                   break;
1700               }
1701             break;
1702           case 0x51:
1703               GETBYTE ();
1704               switch (op[2] & 0x00)
1705               {
1706                 case 0x00:
1707                   goto op_semantics_5;
1708                   break;
1709               }
1710             break;
1711           case 0x52:
1712               GETBYTE ();
1713               switch (op[2] & 0x00)
1714               {
1715                 case 0x00:
1716                   goto op_semantics_5;
1717                   break;
1718               }
1719             break;
1720           case 0x53:
1721               GETBYTE ();
1722               switch (op[2] & 0x00)
1723               {
1724                 case 0x00:
1725                   goto op_semantics_5;
1726                   break;
1727               }
1728             break;
1729           case 0x54:
1730               GETBYTE ();
1731               switch (op[2] & 0x00)
1732               {
1733                 case 0x00:
1734                   goto op_semantics_6;
1735                   break;
1736               }
1737             break;
1738           case 0x55:
1739               GETBYTE ();
1740               switch (op[2] & 0x00)
1741               {
1742                 case 0x00:
1743                   goto op_semantics_6;
1744                   break;
1745               }
1746             break;
1747           case 0x56:
1748               GETBYTE ();
1749               switch (op[2] & 0x00)
1750               {
1751                 case 0x00:
1752                   goto op_semantics_6;
1753                   break;
1754               }
1755             break;
1756           case 0x57:
1757               GETBYTE ();
1758               switch (op[2] & 0x00)
1759               {
1760                 case 0x00:
1761                   goto op_semantics_6;
1762                   break;
1763               }
1764             break;
1765           case 0x60:
1766               GETBYTE ();
1767               switch (op[2] & 0xff)
1768               {
1769                 case 0x00:
1770                     GETBYTE ();
1771                     switch (op[3] & 0x00)
1772                     {
1773                       case 0x00:
1774                         goto op_semantics_7;
1775                         break;
1776                     }
1777                   break;
1778                 case 0x04:
1779                     GETBYTE ();
1780                     switch (op[3] & 0x00)
1781                     {
1782                       case 0x00:
1783                         goto op_semantics_8;
1784                         break;
1785                     }
1786                   break;
1787                 case 0x05:
1788                     GETBYTE ();
1789                     switch (op[3] & 0x00)
1790                     {
1791                       case 0x00:
1792                         goto op_semantics_9;
1793                         break;
1794                     }
1795                   break;
1796                 case 0x06:
1797                     GETBYTE ();
1798                     switch (op[3] & 0x00)
1799                     {
1800                       case 0x00:
1801                         goto op_semantics_10;
1802                         break;
1803                     }
1804                   break;
1805                 case 0x07:
1806                     GETBYTE ();
1807                     switch (op[3] & 0x00)
1808                     {
1809                       case 0x00:
1810                         goto op_semantics_11;
1811                         break;
1812                     }
1813                   break;
1814                 case 0x08:
1815                     GETBYTE ();
1816                     switch (op[3] & 0x00)
1817                     {
1818                       case 0x00:
1819                         goto op_semantics_12;
1820                         break;
1821                     }
1822                   break;
1823                 case 0x09:
1824                     GETBYTE ();
1825                     switch (op[3] & 0x00)
1826                     {
1827                       case 0x00:
1828                         goto op_semantics_13;
1829                         break;
1830                     }
1831                   break;
1832                 case 0x0c:
1833                     GETBYTE ();
1834                     switch (op[3] & 0x00)
1835                     {
1836                       case 0x00:
1837                         goto op_semantics_14;
1838                         break;
1839                     }
1840                   break;
1841                 case 0x0d:
1842                     GETBYTE ();
1843                     switch (op[3] & 0x00)
1844                     {
1845                       case 0x00:
1846                         goto op_semantics_15;
1847                         break;
1848                     }
1849                   break;
1850                 case 0x10:
1851                     GETBYTE ();
1852                     switch (op[3] & 0x00)
1853                     {
1854                       case 0x00:
1855                         goto op_semantics_16;
1856                         break;
1857                     }
1858                   break;
1859                 case 0x11:
1860                     GETBYTE ();
1861                     switch (op[3] & 0x00)
1862                     {
1863                       case 0x00:
1864                         goto op_semantics_17;
1865                         break;
1866                     }
1867                   break;
1868                 case 0x15:
1869                     GETBYTE ();
1870                     switch (op[3] & 0x00)
1871                     {
1872                       case 0x00:
1873                         goto op_semantics_18;
1874                         break;
1875                     }
1876                   break;
1877                 default: UNSUPPORTED(); break;
1878               }
1879             break;
1880           case 0x61:
1881               GETBYTE ();
1882               switch (op[2] & 0xff)
1883               {
1884                 case 0x00:
1885                     GETBYTE ();
1886                     switch (op[3] & 0x00)
1887                     {
1888                       case 0x00:
1889                         goto op_semantics_7;
1890                         break;
1891                     }
1892                   break;
1893                 case 0x04:
1894                     GETBYTE ();
1895                     switch (op[3] & 0x00)
1896                     {
1897                       case 0x00:
1898                         goto op_semantics_8;
1899                         break;
1900                     }
1901                   break;
1902                 case 0x05:
1903                     GETBYTE ();
1904                     switch (op[3] & 0x00)
1905                     {
1906                       case 0x00:
1907                         goto op_semantics_9;
1908                         break;
1909                     }
1910                   break;
1911                 case 0x06:
1912                     GETBYTE ();
1913                     switch (op[3] & 0x00)
1914                     {
1915                       case 0x00:
1916                         goto op_semantics_10;
1917                         break;
1918                     }
1919                   break;
1920                 case 0x07:
1921                     GETBYTE ();
1922                     switch (op[3] & 0x00)
1923                     {
1924                       case 0x00:
1925                         goto op_semantics_11;
1926                         break;
1927                     }
1928                   break;
1929                 case 0x08:
1930                     GETBYTE ();
1931                     switch (op[3] & 0x00)
1932                     {
1933                       case 0x00:
1934                         goto op_semantics_12;
1935                         break;
1936                     }
1937                   break;
1938                 case 0x09:
1939                     GETBYTE ();
1940                     switch (op[3] & 0x00)
1941                     {
1942                       case 0x00:
1943                         goto op_semantics_13;
1944                         break;
1945                     }
1946                   break;
1947                 case 0x0c:
1948                     GETBYTE ();
1949                     switch (op[3] & 0x00)
1950                     {
1951                       case 0x00:
1952                         goto op_semantics_14;
1953                         break;
1954                     }
1955                   break;
1956                 case 0x0d:
1957                     GETBYTE ();
1958                     switch (op[3] & 0x00)
1959                     {
1960                       case 0x00:
1961                         goto op_semantics_15;
1962                         break;
1963                     }
1964                   break;
1965                 case 0x10:
1966                     GETBYTE ();
1967                     switch (op[3] & 0x00)
1968                     {
1969                       case 0x00:
1970                         goto op_semantics_16;
1971                         break;
1972                     }
1973                   break;
1974                 case 0x11:
1975                     GETBYTE ();
1976                     switch (op[3] & 0x00)
1977                     {
1978                       case 0x00:
1979                         goto op_semantics_17;
1980                         break;
1981                     }
1982                   break;
1983                 case 0x15:
1984                     GETBYTE ();
1985                     switch (op[3] & 0x00)
1986                     {
1987                       case 0x00:
1988                         goto op_semantics_18;
1989                         break;
1990                     }
1991                   break;
1992                 default: UNSUPPORTED(); break;
1993               }
1994             break;
1995           case 0x62:
1996               GETBYTE ();
1997               switch (op[2] & 0xff)
1998               {
1999                 case 0x00:
2000                     GETBYTE ();
2001                     switch (op[3] & 0x00)
2002                     {
2003                       case 0x00:
2004                         goto op_semantics_7;
2005                         break;
2006                     }
2007                   break;
2008                 case 0x04:
2009                     GETBYTE ();
2010                     switch (op[3] & 0x00)
2011                     {
2012                       case 0x00:
2013                         goto op_semantics_8;
2014                         break;
2015                     }
2016                   break;
2017                 case 0x05:
2018                     GETBYTE ();
2019                     switch (op[3] & 0x00)
2020                     {
2021                       case 0x00:
2022                         goto op_semantics_9;
2023                         break;
2024                     }
2025                   break;
2026                 case 0x06:
2027                     GETBYTE ();
2028                     switch (op[3] & 0x00)
2029                     {
2030                       case 0x00:
2031                         goto op_semantics_10;
2032                         break;
2033                     }
2034                   break;
2035                 case 0x07:
2036                     GETBYTE ();
2037                     switch (op[3] & 0x00)
2038                     {
2039                       case 0x00:
2040                         goto op_semantics_11;
2041                         break;
2042                     }
2043                   break;
2044                 case 0x08:
2045                     GETBYTE ();
2046                     switch (op[3] & 0x00)
2047                     {
2048                       case 0x00:
2049                         goto op_semantics_12;
2050                         break;
2051                     }
2052                   break;
2053                 case 0x09:
2054                     GETBYTE ();
2055                     switch (op[3] & 0x00)
2056                     {
2057                       case 0x00:
2058                         goto op_semantics_13;
2059                         break;
2060                     }
2061                   break;
2062                 case 0x0c:
2063                     GETBYTE ();
2064                     switch (op[3] & 0x00)
2065                     {
2066                       case 0x00:
2067                         goto op_semantics_14;
2068                         break;
2069                     }
2070                   break;
2071                 case 0x0d:
2072                     GETBYTE ();
2073                     switch (op[3] & 0x00)
2074                     {
2075                       case 0x00:
2076                         goto op_semantics_15;
2077                         break;
2078                     }
2079                   break;
2080                 case 0x10:
2081                     GETBYTE ();
2082                     switch (op[3] & 0x00)
2083                     {
2084                       case 0x00:
2085                         goto op_semantics_16;
2086                         break;
2087                     }
2088                   break;
2089                 case 0x11:
2090                     GETBYTE ();
2091                     switch (op[3] & 0x00)
2092                     {
2093                       case 0x00:
2094                         goto op_semantics_17;
2095                         break;
2096                     }
2097                   break;
2098                 case 0x15:
2099                     GETBYTE ();
2100                     switch (op[3] & 0x00)
2101                     {
2102                       case 0x00:
2103                         goto op_semantics_18;
2104                         break;
2105                     }
2106                   break;
2107                 default: UNSUPPORTED(); break;
2108               }
2109             break;
2110           case 0x63:
2111               GETBYTE ();
2112               switch (op[2] & 0xff)
2113               {
2114                 case 0x00:
2115                     GETBYTE ();
2116                     switch (op[3] & 0x00)
2117                     {
2118                       case 0x00:
2119                         goto op_semantics_7;
2120                         break;
2121                     }
2122                   break;
2123                 case 0x04:
2124                     GETBYTE ();
2125                     switch (op[3] & 0x00)
2126                     {
2127                       case 0x00:
2128                         goto op_semantics_8;
2129                         break;
2130                     }
2131                   break;
2132                 case 0x05:
2133                     GETBYTE ();
2134                     switch (op[3] & 0x00)
2135                     {
2136                       case 0x00:
2137                         goto op_semantics_9;
2138                         break;
2139                     }
2140                   break;
2141                 case 0x06:
2142                     GETBYTE ();
2143                     switch (op[3] & 0x00)
2144                     {
2145                       case 0x00:
2146                         goto op_semantics_10;
2147                         break;
2148                     }
2149                   break;
2150                 case 0x07:
2151                     GETBYTE ();
2152                     switch (op[3] & 0x00)
2153                     {
2154                       case 0x00:
2155                         goto op_semantics_11;
2156                         break;
2157                     }
2158                   break;
2159                 case 0x08:
2160                     GETBYTE ();
2161                     switch (op[3] & 0x00)
2162                     {
2163                       case 0x00:
2164                         goto op_semantics_12;
2165                         break;
2166                     }
2167                   break;
2168                 case 0x09:
2169                     GETBYTE ();
2170                     switch (op[3] & 0x00)
2171                     {
2172                       case 0x00:
2173                         goto op_semantics_13;
2174                         break;
2175                     }
2176                   break;
2177                 case 0x0c:
2178                     GETBYTE ();
2179                     switch (op[3] & 0x00)
2180                     {
2181                       case 0x00:
2182                         goto op_semantics_14;
2183                         break;
2184                     }
2185                   break;
2186                 case 0x0d:
2187                     GETBYTE ();
2188                     switch (op[3] & 0x00)
2189                     {
2190                       case 0x00:
2191                         goto op_semantics_15;
2192                         break;
2193                     }
2194                   break;
2195                 case 0x10:
2196                     GETBYTE ();
2197                     switch (op[3] & 0x00)
2198                     {
2199                       case 0x00:
2200                         goto op_semantics_16;
2201                         break;
2202                     }
2203                   break;
2204                 case 0x11:
2205                     GETBYTE ();
2206                     switch (op[3] & 0x00)
2207                     {
2208                       case 0x00:
2209                         goto op_semantics_17;
2210                         break;
2211                     }
2212                   break;
2213                 case 0x15:
2214                     GETBYTE ();
2215                     switch (op[3] & 0x00)
2216                     {
2217                       case 0x00:
2218                         goto op_semantics_18;
2219                         break;
2220                     }
2221                   break;
2222                 default: UNSUPPORTED(); break;
2223               }
2224             break;
2225           case 0x80:
2226               GETBYTE ();
2227               switch (op[2] & 0x00)
2228               {
2229                 case 0x00:
2230                   goto op_semantics_1;
2231                   break;
2232               }
2233             break;
2234           case 0x81:
2235               GETBYTE ();
2236               switch (op[2] & 0x00)
2237               {
2238                 case 0x00:
2239                   goto op_semantics_1;
2240                   break;
2241               }
2242             break;
2243           case 0x82:
2244               GETBYTE ();
2245               switch (op[2] & 0x00)
2246               {
2247                 case 0x00:
2248                   goto op_semantics_1;
2249                   break;
2250               }
2251             break;
2252           case 0x83:
2253               GETBYTE ();
2254               switch (op[2] & 0x00)
2255               {
2256                 case 0x00:
2257                   goto op_semantics_1;
2258                   break;
2259               }
2260             break;
2261           case 0x84:
2262               GETBYTE ();
2263               switch (op[2] & 0x00)
2264               {
2265                 case 0x00:
2266                   goto op_semantics_2;
2267                   break;
2268               }
2269             break;
2270           case 0x85:
2271               GETBYTE ();
2272               switch (op[2] & 0x00)
2273               {
2274                 case 0x00:
2275                   goto op_semantics_2;
2276                   break;
2277               }
2278             break;
2279           case 0x86:
2280               GETBYTE ();
2281               switch (op[2] & 0x00)
2282               {
2283                 case 0x00:
2284                   goto op_semantics_2;
2285                   break;
2286               }
2287             break;
2288           case 0x87:
2289               GETBYTE ();
2290               switch (op[2] & 0x00)
2291               {
2292                 case 0x00:
2293                   goto op_semantics_2;
2294                   break;
2295               }
2296             break;
2297           case 0x88:
2298               GETBYTE ();
2299               switch (op[2] & 0x00)
2300               {
2301                 case 0x00:
2302                   goto op_semantics_3;
2303                   break;
2304               }
2305             break;
2306           case 0x89:
2307               GETBYTE ();
2308               switch (op[2] & 0x00)
2309               {
2310                 case 0x00:
2311                   goto op_semantics_3;
2312                   break;
2313               }
2314             break;
2315           case 0x8a:
2316               GETBYTE ();
2317               switch (op[2] & 0x00)
2318               {
2319                 case 0x00:
2320                   goto op_semantics_3;
2321                   break;
2322               }
2323             break;
2324           case 0x8b:
2325               GETBYTE ();
2326               switch (op[2] & 0x00)
2327               {
2328                 case 0x00:
2329                   goto op_semantics_3;
2330                   break;
2331               }
2332             break;
2333           case 0x8c:
2334               GETBYTE ();
2335               switch (op[2] & 0x00)
2336               {
2337                 case 0x00:
2338                   goto op_semantics_4;
2339                   break;
2340               }
2341             break;
2342           case 0x8d:
2343               GETBYTE ();
2344               switch (op[2] & 0x00)
2345               {
2346                 case 0x00:
2347                   goto op_semantics_4;
2348                   break;
2349               }
2350             break;
2351           case 0x8e:
2352               GETBYTE ();
2353               switch (op[2] & 0x00)
2354               {
2355                 case 0x00:
2356                   goto op_semantics_4;
2357                   break;
2358               }
2359             break;
2360           case 0x8f:
2361               GETBYTE ();
2362               switch (op[2] & 0x00)
2363               {
2364                 case 0x00:
2365                   goto op_semantics_4;
2366                   break;
2367               }
2368             break;
2369           case 0x90:
2370               GETBYTE ();
2371               switch (op[2] & 0x00)
2372               {
2373                 case 0x00:
2374                   goto op_semantics_5;
2375                   break;
2376               }
2377             break;
2378           case 0x91:
2379               GETBYTE ();
2380               switch (op[2] & 0x00)
2381               {
2382                 case 0x00:
2383                   goto op_semantics_5;
2384                   break;
2385               }
2386             break;
2387           case 0x92:
2388               GETBYTE ();
2389               switch (op[2] & 0x00)
2390               {
2391                 case 0x00:
2392                   goto op_semantics_5;
2393                   break;
2394               }
2395             break;
2396           case 0x93:
2397               GETBYTE ();
2398               switch (op[2] & 0x00)
2399               {
2400                 case 0x00:
2401                   goto op_semantics_5;
2402                   break;
2403               }
2404             break;
2405           case 0x94:
2406               GETBYTE ();
2407               switch (op[2] & 0x00)
2408               {
2409                 case 0x00:
2410                   goto op_semantics_6;
2411                   break;
2412               }
2413             break;
2414           case 0x95:
2415               GETBYTE ();
2416               switch (op[2] & 0x00)
2417               {
2418                 case 0x00:
2419                   goto op_semantics_6;
2420                   break;
2421               }
2422             break;
2423           case 0x96:
2424               GETBYTE ();
2425               switch (op[2] & 0x00)
2426               {
2427                 case 0x00:
2428                   goto op_semantics_6;
2429                   break;
2430               }
2431             break;
2432           case 0x97:
2433               GETBYTE ();
2434               switch (op[2] & 0x00)
2435               {
2436                 case 0x00:
2437                   goto op_semantics_6;
2438                   break;
2439               }
2440             break;
2441           case 0xa0:
2442               GETBYTE ();
2443               switch (op[2] & 0xff)
2444               {
2445                 case 0x00:
2446                     GETBYTE ();
2447                     switch (op[3] & 0x00)
2448                     {
2449                       case 0x00:
2450                         goto op_semantics_7;
2451                         break;
2452                     }
2453                   break;
2454                 case 0x02:
2455                     GETBYTE ();
2456                     switch (op[3] & 0x00)
2457                     {
2458                       case 0x00:
2459                         op_semantics_19:
2460                           {
2461                             /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc     %1%S1, %0 */
2462 #line 494 "rx-decode.opc"
2463                             int ss AU = op[1] & 0x03;
2464 #line 494 "rx-decode.opc"
2465                             int rsrc AU = (op[3] >> 4) & 0x0f;
2466 #line 494 "rx-decode.opc"
2467                             int rdst AU = op[3] & 0x0f;
2468                             if (trace)
2469                               {
2470                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
2471                                        "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst     adc     %1%S1, %0 */",
2472                                        op[0], op[1], op[2], op[3]);
2473                                 printf ("  ss = 0x%x,", ss);
2474                                 printf ("  rsrc = 0x%x,", rsrc);
2475                                 printf ("  rdst = 0x%x\n", rdst);
2476                               }
2477                             SYNTAX("adc %1%S1, %0");
2478 #line 494 "rx-decode.opc"
2479                             ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2480
2481                           /*----------------------------------------------------------------------*/
2482                           /* ADD                                                                        */
2483
2484                           }
2485                         break;
2486                     }
2487                   break;
2488                 case 0x04:
2489                     GETBYTE ();
2490                     switch (op[3] & 0x00)
2491                     {
2492                       case 0x00:
2493                         goto op_semantics_8;
2494                         break;
2495                     }
2496                   break;
2497                 case 0x05:
2498                     GETBYTE ();
2499                     switch (op[3] & 0x00)
2500                     {
2501                       case 0x00:
2502                         goto op_semantics_9;
2503                         break;
2504                     }
2505                   break;
2506                 case 0x06:
2507                     GETBYTE ();
2508                     switch (op[3] & 0x00)
2509                     {
2510                       case 0x00:
2511                         goto op_semantics_10;
2512                         break;
2513                     }
2514                   break;
2515                 case 0x07:
2516                     GETBYTE ();
2517                     switch (op[3] & 0x00)
2518                     {
2519                       case 0x00:
2520                         goto op_semantics_11;
2521                         break;
2522                     }
2523                   break;
2524                 case 0x08:
2525                     GETBYTE ();
2526                     switch (op[3] & 0x00)
2527                     {
2528                       case 0x00:
2529                         goto op_semantics_12;
2530                         break;
2531                     }
2532                   break;
2533                 case 0x09:
2534                     GETBYTE ();
2535                     switch (op[3] & 0x00)
2536                     {
2537                       case 0x00:
2538                         goto op_semantics_13;
2539                         break;
2540                     }
2541                   break;
2542                 case 0x0c:
2543                     GETBYTE ();
2544                     switch (op[3] & 0x00)
2545                     {
2546                       case 0x00:
2547                         goto op_semantics_14;
2548                         break;
2549                     }
2550                   break;
2551                 case 0x0d:
2552                     GETBYTE ();
2553                     switch (op[3] & 0x00)
2554                     {
2555                       case 0x00:
2556                         goto op_semantics_15;
2557                         break;
2558                     }
2559                   break;
2560                 case 0x10:
2561                     GETBYTE ();
2562                     switch (op[3] & 0x00)
2563                     {
2564                       case 0x00:
2565                         goto op_semantics_16;
2566                         break;
2567                     }
2568                   break;
2569                 case 0x11:
2570                     GETBYTE ();
2571                     switch (op[3] & 0x00)
2572                     {
2573                       case 0x00:
2574                         goto op_semantics_17;
2575                         break;
2576                     }
2577                   break;
2578                 case 0x15:
2579                     GETBYTE ();
2580                     switch (op[3] & 0x00)
2581                     {
2582                       case 0x00:
2583                         goto op_semantics_18;
2584                         break;
2585                     }
2586                   break;
2587                 default: UNSUPPORTED(); break;
2588               }
2589             break;
2590           case 0xa1:
2591               GETBYTE ();
2592               switch (op[2] & 0xff)
2593               {
2594                 case 0x00:
2595                     GETBYTE ();
2596                     switch (op[3] & 0x00)
2597                     {
2598                       case 0x00:
2599                         goto op_semantics_7;
2600                         break;
2601                     }
2602                   break;
2603                 case 0x02:
2604                     GETBYTE ();
2605                     switch (op[3] & 0x00)
2606                     {
2607                       case 0x00:
2608                         goto op_semantics_19;
2609                         break;
2610                     }
2611                   break;
2612                 case 0x04:
2613                     GETBYTE ();
2614                     switch (op[3] & 0x00)
2615                     {
2616                       case 0x00:
2617                         goto op_semantics_8;
2618                         break;
2619                     }
2620                   break;
2621                 case 0x05:
2622                     GETBYTE ();
2623                     switch (op[3] & 0x00)
2624                     {
2625                       case 0x00:
2626                         goto op_semantics_9;
2627                         break;
2628                     }
2629                   break;
2630                 case 0x06:
2631                     GETBYTE ();
2632                     switch (op[3] & 0x00)
2633                     {
2634                       case 0x00:
2635                         goto op_semantics_10;
2636                         break;
2637                     }
2638                   break;
2639                 case 0x07:
2640                     GETBYTE ();
2641                     switch (op[3] & 0x00)
2642                     {
2643                       case 0x00:
2644                         goto op_semantics_11;
2645                         break;
2646                     }
2647                   break;
2648                 case 0x08:
2649                     GETBYTE ();
2650                     switch (op[3] & 0x00)
2651                     {
2652                       case 0x00:
2653                         goto op_semantics_12;
2654                         break;
2655                     }
2656                   break;
2657                 case 0x09:
2658                     GETBYTE ();
2659                     switch (op[3] & 0x00)
2660                     {
2661                       case 0x00:
2662                         goto op_semantics_13;
2663                         break;
2664                     }
2665                   break;
2666                 case 0x0c:
2667                     GETBYTE ();
2668                     switch (op[3] & 0x00)
2669                     {
2670                       case 0x00:
2671                         goto op_semantics_14;
2672                         break;
2673                     }
2674                   break;
2675                 case 0x0d:
2676                     GETBYTE ();
2677                     switch (op[3] & 0x00)
2678                     {
2679                       case 0x00:
2680                         goto op_semantics_15;
2681                         break;
2682                     }
2683                   break;
2684                 case 0x10:
2685                     GETBYTE ();
2686                     switch (op[3] & 0x00)
2687                     {
2688                       case 0x00:
2689                         goto op_semantics_16;
2690                         break;
2691                     }
2692                   break;
2693                 case 0x11:
2694                     GETBYTE ();
2695                     switch (op[3] & 0x00)
2696                     {
2697                       case 0x00:
2698                         goto op_semantics_17;
2699                         break;
2700                     }
2701                   break;
2702                 case 0x15:
2703                     GETBYTE ();
2704                     switch (op[3] & 0x00)
2705                     {
2706                       case 0x00:
2707                         goto op_semantics_18;
2708                         break;
2709                     }
2710                   break;
2711                 default: UNSUPPORTED(); break;
2712               }
2713             break;
2714           case 0xa2:
2715               GETBYTE ();
2716               switch (op[2] & 0xff)
2717               {
2718                 case 0x00:
2719                     GETBYTE ();
2720                     switch (op[3] & 0x00)
2721                     {
2722                       case 0x00:
2723                         goto op_semantics_7;
2724                         break;
2725                     }
2726                   break;
2727                 case 0x02:
2728                     GETBYTE ();
2729                     switch (op[3] & 0x00)
2730                     {
2731                       case 0x00:
2732                         goto op_semantics_19;
2733                         break;
2734                     }
2735                   break;
2736                 case 0x04:
2737                     GETBYTE ();
2738                     switch (op[3] & 0x00)
2739                     {
2740                       case 0x00:
2741                         goto op_semantics_8;
2742                         break;
2743                     }
2744                   break;
2745                 case 0x05:
2746                     GETBYTE ();
2747                     switch (op[3] & 0x00)
2748                     {
2749                       case 0x00:
2750                         goto op_semantics_9;
2751                         break;
2752                     }
2753                   break;
2754                 case 0x06:
2755                     GETBYTE ();
2756                     switch (op[3] & 0x00)
2757                     {
2758                       case 0x00:
2759                         goto op_semantics_10;
2760                         break;
2761                     }
2762                   break;
2763                 case 0x07:
2764                     GETBYTE ();
2765                     switch (op[3] & 0x00)
2766                     {
2767                       case 0x00:
2768                         goto op_semantics_11;
2769                         break;
2770                     }
2771                   break;
2772                 case 0x08:
2773                     GETBYTE ();
2774                     switch (op[3] & 0x00)
2775                     {
2776                       case 0x00:
2777                         goto op_semantics_12;
2778                         break;
2779                     }
2780                   break;
2781                 case 0x09:
2782                     GETBYTE ();
2783                     switch (op[3] & 0x00)
2784                     {
2785                       case 0x00:
2786                         goto op_semantics_13;
2787                         break;
2788                     }
2789                   break;
2790                 case 0x0c:
2791                     GETBYTE ();
2792                     switch (op[3] & 0x00)
2793                     {
2794                       case 0x00:
2795                         goto op_semantics_14;
2796                         break;
2797                     }
2798                   break;
2799                 case 0x0d:
2800                     GETBYTE ();
2801                     switch (op[3] & 0x00)
2802                     {
2803                       case 0x00:
2804                         goto op_semantics_15;
2805                         break;
2806                     }
2807                   break;
2808                 case 0x10:
2809                     GETBYTE ();
2810                     switch (op[3] & 0x00)
2811                     {
2812                       case 0x00:
2813                         goto op_semantics_16;
2814                         break;
2815                     }
2816                   break;
2817                 case 0x11:
2818                     GETBYTE ();
2819                     switch (op[3] & 0x00)
2820                     {
2821                       case 0x00:
2822                         goto op_semantics_17;
2823                         break;
2824                     }
2825                   break;
2826                 case 0x15:
2827                     GETBYTE ();
2828                     switch (op[3] & 0x00)
2829                     {
2830                       case 0x00:
2831                         goto op_semantics_18;
2832                         break;
2833                     }
2834                   break;
2835                 default: UNSUPPORTED(); break;
2836               }
2837             break;
2838           case 0xa3:
2839               GETBYTE ();
2840               switch (op[2] & 0xff)
2841               {
2842                 case 0x00:
2843                     GETBYTE ();
2844                     switch (op[3] & 0x00)
2845                     {
2846                       case 0x00:
2847                         goto op_semantics_7;
2848                         break;
2849                     }
2850                   break;
2851                 case 0x02:
2852                     GETBYTE ();
2853                     switch (op[3] & 0x00)
2854                     {
2855                       case 0x00:
2856                         goto op_semantics_19;
2857                         break;
2858                     }
2859                   break;
2860                 case 0x04:
2861                     GETBYTE ();
2862                     switch (op[3] & 0x00)
2863                     {
2864                       case 0x00:
2865                         goto op_semantics_8;
2866                         break;
2867                     }
2868                   break;
2869                 case 0x05:
2870                     GETBYTE ();
2871                     switch (op[3] & 0x00)
2872                     {
2873                       case 0x00:
2874                         goto op_semantics_9;
2875                         break;
2876                     }
2877                   break;
2878                 case 0x06:
2879                     GETBYTE ();
2880                     switch (op[3] & 0x00)
2881                     {
2882                       case 0x00:
2883                         goto op_semantics_10;
2884                         break;
2885                     }
2886                   break;
2887                 case 0x07:
2888                     GETBYTE ();
2889                     switch (op[3] & 0x00)
2890                     {
2891                       case 0x00:
2892                         goto op_semantics_11;
2893                         break;
2894                     }
2895                   break;
2896                 case 0x08:
2897                     GETBYTE ();
2898                     switch (op[3] & 0x00)
2899                     {
2900                       case 0x00:
2901                         goto op_semantics_12;
2902                         break;
2903                     }
2904                   break;
2905                 case 0x09:
2906                     GETBYTE ();
2907                     switch (op[3] & 0x00)
2908                     {
2909                       case 0x00:
2910                         goto op_semantics_13;
2911                         break;
2912                     }
2913                   break;
2914                 case 0x0c:
2915                     GETBYTE ();
2916                     switch (op[3] & 0x00)
2917                     {
2918                       case 0x00:
2919                         goto op_semantics_14;
2920                         break;
2921                     }
2922                   break;
2923                 case 0x0d:
2924                     GETBYTE ();
2925                     switch (op[3] & 0x00)
2926                     {
2927                       case 0x00:
2928                         goto op_semantics_15;
2929                         break;
2930                     }
2931                   break;
2932                 case 0x10:
2933                     GETBYTE ();
2934                     switch (op[3] & 0x00)
2935                     {
2936                       case 0x00:
2937                         goto op_semantics_16;
2938                         break;
2939                     }
2940                   break;
2941                 case 0x11:
2942                     GETBYTE ();
2943                     switch (op[3] & 0x00)
2944                     {
2945                       case 0x00:
2946                         goto op_semantics_17;
2947                         break;
2948                     }
2949                   break;
2950                 case 0x15:
2951                     GETBYTE ();
2952                     switch (op[3] & 0x00)
2953                     {
2954                       case 0x00:
2955                         goto op_semantics_18;
2956                         break;
2957                     }
2958                   break;
2959                 default: UNSUPPORTED(); break;
2960               }
2961             break;
2962           case 0xc0:
2963               GETBYTE ();
2964               switch (op[2] & 0x00)
2965               {
2966                 case 0x00:
2967                   goto op_semantics_1;
2968                   break;
2969               }
2970             break;
2971           case 0xc1:
2972               GETBYTE ();
2973               switch (op[2] & 0x00)
2974               {
2975                 case 0x00:
2976                   goto op_semantics_1;
2977                   break;
2978               }
2979             break;
2980           case 0xc2:
2981               GETBYTE ();
2982               switch (op[2] & 0x00)
2983               {
2984                 case 0x00:
2985                   goto op_semantics_1;
2986                   break;
2987               }
2988             break;
2989           case 0xc3:
2990               GETBYTE ();
2991               switch (op[2] & 0x00)
2992               {
2993                 case 0x00:
2994                   goto op_semantics_1;
2995                   break;
2996               }
2997             break;
2998           case 0xc4:
2999               GETBYTE ();
3000               switch (op[2] & 0x00)
3001               {
3002                 case 0x00:
3003                   goto op_semantics_2;
3004                   break;
3005               }
3006             break;
3007           case 0xc5:
3008               GETBYTE ();
3009               switch (op[2] & 0x00)
3010               {
3011                 case 0x00:
3012                   goto op_semantics_2;
3013                   break;
3014               }
3015             break;
3016           case 0xc6:
3017               GETBYTE ();
3018               switch (op[2] & 0x00)
3019               {
3020                 case 0x00:
3021                   goto op_semantics_2;
3022                   break;
3023               }
3024             break;
3025           case 0xc7:
3026               GETBYTE ();
3027               switch (op[2] & 0x00)
3028               {
3029                 case 0x00:
3030                   goto op_semantics_2;
3031                   break;
3032               }
3033             break;
3034           case 0xc8:
3035               GETBYTE ();
3036               switch (op[2] & 0x00)
3037               {
3038                 case 0x00:
3039                   goto op_semantics_3;
3040                   break;
3041               }
3042             break;
3043           case 0xc9:
3044               GETBYTE ();
3045               switch (op[2] & 0x00)
3046               {
3047                 case 0x00:
3048                   goto op_semantics_3;
3049                   break;
3050               }
3051             break;
3052           case 0xca:
3053               GETBYTE ();
3054               switch (op[2] & 0x00)
3055               {
3056                 case 0x00:
3057                   goto op_semantics_3;
3058                   break;
3059               }
3060             break;
3061           case 0xcb:
3062               GETBYTE ();
3063               switch (op[2] & 0x00)
3064               {
3065                 case 0x00:
3066                   goto op_semantics_3;
3067                   break;
3068               }
3069             break;
3070           case 0xcc:
3071               GETBYTE ();
3072               switch (op[2] & 0x00)
3073               {
3074                 case 0x00:
3075                   goto op_semantics_4;
3076                   break;
3077               }
3078             break;
3079           case 0xcd:
3080               GETBYTE ();
3081               switch (op[2] & 0x00)
3082               {
3083                 case 0x00:
3084                   goto op_semantics_4;
3085                   break;
3086               }
3087             break;
3088           case 0xce:
3089               GETBYTE ();
3090               switch (op[2] & 0x00)
3091               {
3092                 case 0x00:
3093                   goto op_semantics_4;
3094                   break;
3095               }
3096             break;
3097           case 0xcf:
3098               GETBYTE ();
3099               switch (op[2] & 0x00)
3100               {
3101                 case 0x00:
3102                   goto op_semantics_4;
3103                   break;
3104               }
3105             break;
3106           case 0xd0:
3107               GETBYTE ();
3108               switch (op[2] & 0x00)
3109               {
3110                 case 0x00:
3111                   goto op_semantics_5;
3112                   break;
3113               }
3114             break;
3115           case 0xd1:
3116               GETBYTE ();
3117               switch (op[2] & 0x00)
3118               {
3119                 case 0x00:
3120                   goto op_semantics_5;
3121                   break;
3122               }
3123             break;
3124           case 0xd2:
3125               GETBYTE ();
3126               switch (op[2] & 0x00)
3127               {
3128                 case 0x00:
3129                   goto op_semantics_5;
3130                   break;
3131               }
3132             break;
3133           case 0xd3:
3134               GETBYTE ();
3135               switch (op[2] & 0x00)
3136               {
3137                 case 0x00:
3138                   goto op_semantics_5;
3139                   break;
3140               }
3141             break;
3142           case 0xd4:
3143               GETBYTE ();
3144               switch (op[2] & 0x00)
3145               {
3146                 case 0x00:
3147                   goto op_semantics_6;
3148                   break;
3149               }
3150             break;
3151           case 0xd5:
3152               GETBYTE ();
3153               switch (op[2] & 0x00)
3154               {
3155                 case 0x00:
3156                   goto op_semantics_6;
3157                   break;
3158               }
3159             break;
3160           case 0xd6:
3161               GETBYTE ();
3162               switch (op[2] & 0x00)
3163               {
3164                 case 0x00:
3165                   goto op_semantics_6;
3166                   break;
3167               }
3168             break;
3169           case 0xd7:
3170               GETBYTE ();
3171               switch (op[2] & 0x00)
3172               {
3173                 case 0x00:
3174                   goto op_semantics_6;
3175                   break;
3176               }
3177             break;
3178           case 0xe0:
3179               GETBYTE ();
3180               switch (op[2] & 0xff)
3181               {
3182                 case 0x00:
3183                     GETBYTE ();
3184                     switch (op[3] & 0x00)
3185                     {
3186                       case 0x00:
3187                         goto op_semantics_7;
3188                         break;
3189                     }
3190                   break;
3191                 case 0x04:
3192                     GETBYTE ();
3193                     switch (op[3] & 0x00)
3194                     {
3195                       case 0x00:
3196                         goto op_semantics_8;
3197                         break;
3198                     }
3199                   break;
3200                 case 0x05:
3201                     GETBYTE ();
3202                     switch (op[3] & 0x00)
3203                     {
3204                       case 0x00:
3205                         goto op_semantics_9;
3206                         break;
3207                     }
3208                   break;
3209                 case 0x06:
3210                     GETBYTE ();
3211                     switch (op[3] & 0x00)
3212                     {
3213                       case 0x00:
3214                         goto op_semantics_10;
3215                         break;
3216                     }
3217                   break;
3218                 case 0x07:
3219                     GETBYTE ();
3220                     switch (op[3] & 0x00)
3221                     {
3222                       case 0x00:
3223                         goto op_semantics_11;
3224                         break;
3225                     }
3226                   break;
3227                 case 0x08:
3228                     GETBYTE ();
3229                     switch (op[3] & 0x00)
3230                     {
3231                       case 0x00:
3232                         goto op_semantics_12;
3233                         break;
3234                     }
3235                   break;
3236                 case 0x09:
3237                     GETBYTE ();
3238                     switch (op[3] & 0x00)
3239                     {
3240                       case 0x00:
3241                         goto op_semantics_13;
3242                         break;
3243                     }
3244                   break;
3245                 case 0x0c:
3246                     GETBYTE ();
3247                     switch (op[3] & 0x00)
3248                     {
3249                       case 0x00:
3250                         goto op_semantics_14;
3251                         break;
3252                     }
3253                   break;
3254                 case 0x0d:
3255                     GETBYTE ();
3256                     switch (op[3] & 0x00)
3257                     {
3258                       case 0x00:
3259                         goto op_semantics_15;
3260                         break;
3261                     }
3262                   break;
3263                 case 0x10:
3264                     GETBYTE ();
3265                     switch (op[3] & 0x00)
3266                     {
3267                       case 0x00:
3268                         goto op_semantics_16;
3269                         break;
3270                     }
3271                   break;
3272                 case 0x11:
3273                     GETBYTE ();
3274                     switch (op[3] & 0x00)
3275                     {
3276                       case 0x00:
3277                         goto op_semantics_17;
3278                         break;
3279                     }
3280                   break;
3281                 case 0x15:
3282                     GETBYTE ();
3283                     switch (op[3] & 0x00)
3284                     {
3285                       case 0x00:
3286                         goto op_semantics_18;
3287                         break;
3288                     }
3289                   break;
3290                 default: UNSUPPORTED(); break;
3291               }
3292             break;
3293           case 0xe1:
3294               GETBYTE ();
3295               switch (op[2] & 0xff)
3296               {
3297                 case 0x00:
3298                     GETBYTE ();
3299                     switch (op[3] & 0x00)
3300                     {
3301                       case 0x00:
3302                         goto op_semantics_7;
3303                         break;
3304                     }
3305                   break;
3306                 case 0x04:
3307                     GETBYTE ();
3308                     switch (op[3] & 0x00)
3309                     {
3310                       case 0x00:
3311                         goto op_semantics_8;
3312                         break;
3313                     }
3314                   break;
3315                 case 0x05:
3316                     GETBYTE ();
3317                     switch (op[3] & 0x00)
3318                     {
3319                       case 0x00:
3320                         goto op_semantics_9;
3321                         break;
3322                     }
3323                   break;
3324                 case 0x06:
3325                     GETBYTE ();
3326                     switch (op[3] & 0x00)
3327                     {
3328                       case 0x00:
3329                         goto op_semantics_10;
3330                         break;
3331                     }
3332                   break;
3333                 case 0x07:
3334                     GETBYTE ();
3335                     switch (op[3] & 0x00)
3336                     {
3337                       case 0x00:
3338                         goto op_semantics_11;
3339                         break;
3340                     }
3341                   break;
3342                 case 0x08:
3343                     GETBYTE ();
3344                     switch (op[3] & 0x00)
3345                     {
3346                       case 0x00:
3347                         goto op_semantics_12;
3348                         break;
3349                     }
3350                   break;
3351                 case 0x09:
3352                     GETBYTE ();
3353                     switch (op[3] & 0x00)
3354                     {
3355                       case 0x00:
3356                         goto op_semantics_13;
3357                         break;
3358                     }
3359                   break;
3360                 case 0x0c:
3361                     GETBYTE ();
3362                     switch (op[3] & 0x00)
3363                     {
3364                       case 0x00:
3365                         goto op_semantics_14;
3366                         break;
3367                     }
3368                   break;
3369                 case 0x0d:
3370                     GETBYTE ();
3371                     switch (op[3] & 0x00)
3372                     {
3373                       case 0x00:
3374                         goto op_semantics_15;
3375                         break;
3376                     }
3377                   break;
3378                 case 0x10:
3379                     GETBYTE ();
3380                     switch (op[3] & 0x00)
3381                     {
3382                       case 0x00:
3383                         goto op_semantics_16;
3384                         break;
3385                     }
3386                   break;
3387                 case 0x11:
3388                     GETBYTE ();
3389                     switch (op[3] & 0x00)
3390                     {
3391                       case 0x00:
3392                         goto op_semantics_17;
3393                         break;
3394                     }
3395                   break;
3396                 case 0x15:
3397                     GETBYTE ();
3398                     switch (op[3] & 0x00)
3399                     {
3400                       case 0x00:
3401                         goto op_semantics_18;
3402                         break;
3403                     }
3404                   break;
3405                 default: UNSUPPORTED(); break;
3406               }
3407             break;
3408           case 0xe2:
3409               GETBYTE ();
3410               switch (op[2] & 0xff)
3411               {
3412                 case 0x00:
3413                     GETBYTE ();
3414                     switch (op[3] & 0x00)
3415                     {
3416                       case 0x00:
3417                         goto op_semantics_7;
3418                         break;
3419                     }
3420                   break;
3421                 case 0x04:
3422                     GETBYTE ();
3423                     switch (op[3] & 0x00)
3424                     {
3425                       case 0x00:
3426                         goto op_semantics_8;
3427                         break;
3428                     }
3429                   break;
3430                 case 0x05:
3431                     GETBYTE ();
3432                     switch (op[3] & 0x00)
3433                     {
3434                       case 0x00:
3435                         goto op_semantics_9;
3436                         break;
3437                     }
3438                   break;
3439                 case 0x06:
3440                     GETBYTE ();
3441                     switch (op[3] & 0x00)
3442                     {
3443                       case 0x00:
3444                         goto op_semantics_10;
3445                         break;
3446                     }
3447                   break;
3448                 case 0x07:
3449                     GETBYTE ();
3450                     switch (op[3] & 0x00)
3451                     {
3452                       case 0x00:
3453                         goto op_semantics_11;
3454                         break;
3455                     }
3456                   break;
3457                 case 0x08:
3458                     GETBYTE ();
3459                     switch (op[3] & 0x00)
3460                     {
3461                       case 0x00:
3462                         goto op_semantics_12;
3463                         break;
3464                     }
3465                   break;
3466                 case 0x09:
3467                     GETBYTE ();
3468                     switch (op[3] & 0x00)
3469                     {
3470                       case 0x00:
3471                         goto op_semantics_13;
3472                         break;
3473                     }
3474                   break;
3475                 case 0x0c:
3476                     GETBYTE ();
3477                     switch (op[3] & 0x00)
3478                     {
3479                       case 0x00:
3480                         goto op_semantics_14;
3481                         break;
3482                     }
3483                   break;
3484                 case 0x0d:
3485                     GETBYTE ();
3486                     switch (op[3] & 0x00)
3487                     {
3488                       case 0x00:
3489                         goto op_semantics_15;
3490                         break;
3491                     }
3492                   break;
3493                 case 0x10:
3494                     GETBYTE ();
3495                     switch (op[3] & 0x00)
3496                     {
3497                       case 0x00:
3498                         goto op_semantics_16;
3499                         break;
3500                     }
3501                   break;
3502                 case 0x11:
3503                     GETBYTE ();
3504                     switch (op[3] & 0x00)
3505                     {
3506                       case 0x00:
3507                         goto op_semantics_17;
3508                         break;
3509                     }
3510                   break;
3511                 case 0x15:
3512                     GETBYTE ();
3513                     switch (op[3] & 0x00)
3514                     {
3515                       case 0x00:
3516                         goto op_semantics_18;
3517                         break;
3518                     }
3519                   break;
3520                 default: UNSUPPORTED(); break;
3521               }
3522             break;
3523           case 0xe3:
3524               GETBYTE ();
3525               switch (op[2] & 0xff)
3526               {
3527                 case 0x00:
3528                     GETBYTE ();
3529                     switch (op[3] & 0x00)
3530                     {
3531                       case 0x00:
3532                         goto op_semantics_7;
3533                         break;
3534                     }
3535                   break;
3536                 case 0x04:
3537                     GETBYTE ();
3538                     switch (op[3] & 0x00)
3539                     {
3540                       case 0x00:
3541                         goto op_semantics_8;
3542                         break;
3543                     }
3544                   break;
3545                 case 0x05:
3546                     GETBYTE ();
3547                     switch (op[3] & 0x00)
3548                     {
3549                       case 0x00:
3550                         goto op_semantics_9;
3551                         break;
3552                     }
3553                   break;
3554                 case 0x06:
3555                     GETBYTE ();
3556                     switch (op[3] & 0x00)
3557                     {
3558                       case 0x00:
3559                         goto op_semantics_10;
3560                         break;
3561                     }
3562                   break;
3563                 case 0x07:
3564                     GETBYTE ();
3565                     switch (op[3] & 0x00)
3566                     {
3567                       case 0x00:
3568                         goto op_semantics_11;
3569                         break;
3570                     }
3571                   break;
3572                 case 0x08:
3573                     GETBYTE ();
3574                     switch (op[3] & 0x00)
3575                     {
3576                       case 0x00:
3577                         goto op_semantics_12;
3578                         break;
3579                     }
3580                   break;
3581                 case 0x09:
3582                     GETBYTE ();
3583                     switch (op[3] & 0x00)
3584                     {
3585                       case 0x00:
3586                         goto op_semantics_13;
3587                         break;
3588                     }
3589                   break;
3590                 case 0x0c:
3591                     GETBYTE ();
3592                     switch (op[3] & 0x00)
3593                     {
3594                       case 0x00:
3595                         goto op_semantics_14;
3596                         break;
3597                     }
3598                   break;
3599                 case 0x0d:
3600                     GETBYTE ();
3601                     switch (op[3] & 0x00)
3602                     {
3603                       case 0x00:
3604                         goto op_semantics_15;
3605                         break;
3606                     }
3607                   break;
3608                 case 0x10:
3609                     GETBYTE ();
3610                     switch (op[3] & 0x00)
3611                     {
3612                       case 0x00:
3613                         goto op_semantics_16;
3614                         break;
3615                     }
3616                   break;
3617                 case 0x11:
3618                     GETBYTE ();
3619                     switch (op[3] & 0x00)
3620                     {
3621                       case 0x00:
3622                         goto op_semantics_17;
3623                         break;
3624                     }
3625                   break;
3626                 case 0x15:
3627                     GETBYTE ();
3628                     switch (op[3] & 0x00)
3629                     {
3630                       case 0x00:
3631                         goto op_semantics_18;
3632                         break;
3633                     }
3634                   break;
3635                 default: UNSUPPORTED(); break;
3636               }
3637             break;
3638           default: UNSUPPORTED(); break;
3639         }
3640       break;
3641     case 0x08:
3642     case 0x09:
3643     case 0x0a:
3644     case 0x0b:
3645     case 0x0c:
3646     case 0x0d:
3647     case 0x0e:
3648     case 0x0f:
3649         {
3650           /** 0000 1dsp                 bra.s   %a0 */
3651 #line 775 "rx-decode.opc"
3652           int dsp AU = op[0] & 0x07;
3653           if (trace)
3654             {
3655               printf ("\033[33m%s\033[0m  %02x\n",
3656                      "/** 0000 1dsp                     bra.s   %a0 */",
3657                      op[0]);
3658               printf ("  dsp = 0x%x\n", dsp);
3659             }
3660           SYNTAX("bra.s %a0");
3661 #line 775 "rx-decode.opc"
3662           ID(branch); DC(pc + dsp3map[dsp]);
3663
3664         }
3665       break;
3666     case 0x10:
3667     case 0x11:
3668     case 0x12:
3669     case 0x13:
3670     case 0x14:
3671     case 0x15:
3672     case 0x16:
3673     case 0x17:
3674     case 0x18:
3675     case 0x19:
3676     case 0x1a:
3677     case 0x1b:
3678     case 0x1c:
3679     case 0x1d:
3680     case 0x1e:
3681     case 0x1f:
3682         {
3683           /** 0001 n dsp                        b%1.s   %a0 */
3684 #line 765 "rx-decode.opc"
3685           int n AU = (op[0] >> 3) & 0x01;
3686 #line 765 "rx-decode.opc"
3687           int dsp AU = op[0] & 0x07;
3688           if (trace)
3689             {
3690               printf ("\033[33m%s\033[0m  %02x\n",
3691                      "/** 0001 n dsp                    b%1.s   %a0 */",
3692                      op[0]);
3693               printf ("  n = 0x%x,", n);
3694               printf ("  dsp = 0x%x\n", dsp);
3695             }
3696           SYNTAX("b%1.s %a0");
3697 #line 765 "rx-decode.opc"
3698           ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3699
3700         }
3701       break;
3702     case 0x20:
3703     case 0x21:
3704     case 0x22:
3705     case 0x23:
3706     case 0x24:
3707     case 0x25:
3708     case 0x26:
3709     case 0x27:
3710     case 0x28:
3711     case 0x29:
3712     case 0x2a:
3713     case 0x2b:
3714     case 0x2c:
3715     case 0x2d:
3716     case 0x2f:
3717         {
3718           /** 0010 cond                 b%1.b   %a0 */
3719 #line 768 "rx-decode.opc"
3720           int cond AU = op[0] & 0x0f;
3721           if (trace)
3722             {
3723               printf ("\033[33m%s\033[0m  %02x\n",
3724                      "/** 0010 cond                     b%1.b   %a0 */",
3725                      op[0]);
3726               printf ("  cond = 0x%x\n", cond);
3727             }
3728           SYNTAX("b%1.b %a0");
3729 #line 768 "rx-decode.opc"
3730           ID(branch); Scc(cond); DC(pc + IMMex (1));
3731
3732         }
3733       break;
3734     case 0x2e:
3735         {
3736           /** 0010 1110                 bra.b   %a0 */
3737           if (trace)
3738             {
3739               printf ("\033[33m%s\033[0m  %02x\n",
3740                      "/** 0010 1110                     bra.b   %a0 */",
3741                      op[0]);
3742             }
3743           SYNTAX("bra.b %a0");
3744 #line 778 "rx-decode.opc"
3745           ID(branch); DC(pc + IMMex(1));
3746
3747         }
3748       break;
3749     case 0x38:
3750         {
3751           /** 0011 1000                 bra.w   %a0 */
3752           if (trace)
3753             {
3754               printf ("\033[33m%s\033[0m  %02x\n",
3755                      "/** 0011 1000                     bra.w   %a0 */",
3756                      op[0]);
3757             }
3758           SYNTAX("bra.w %a0");
3759 #line 781 "rx-decode.opc"
3760           ID(branch); DC(pc + IMMex(2));
3761
3762         }
3763       break;
3764     case 0x39:
3765         {
3766           /** 0011 1001                 bsr.w   %a0 */
3767           if (trace)
3768             {
3769               printf ("\033[33m%s\033[0m  %02x\n",
3770                      "/** 0011 1001                     bsr.w   %a0 */",
3771                      op[0]);
3772             }
3773           SYNTAX("bsr.w %a0");
3774 #line 797 "rx-decode.opc"
3775           ID(jsr); DC(pc + IMMex(2));
3776
3777         }
3778       break;
3779     case 0x3a:
3780     case 0x3b:
3781         {
3782           /** 0011 101c                 b%1.w   %a0 */
3783 #line 771 "rx-decode.opc"
3784           int c AU = op[0] & 0x01;
3785           if (trace)
3786             {
3787               printf ("\033[33m%s\033[0m  %02x\n",
3788                      "/** 0011 101c                     b%1.w   %a0 */",
3789                      op[0]);
3790               printf ("  c = 0x%x\n", c);
3791             }
3792           SYNTAX("b%1.w %a0");
3793 #line 771 "rx-decode.opc"
3794           ID(branch); Scc(c); DC(pc + IMMex (2));
3795
3796
3797         }
3798       break;
3799     case 0x3c:
3800         GETBYTE ();
3801         switch (op[1] & 0x00)
3802         {
3803           case 0x00:
3804             op_semantics_20:
3805               {
3806                 /** 0011 11sz d dst sppp                mov%s   #%1, %0 */
3807 #line 307 "rx-decode.opc"
3808                 int sz AU = op[0] & 0x03;
3809 #line 307 "rx-decode.opc"
3810                 int d AU = (op[1] >> 7) & 0x01;
3811 #line 307 "rx-decode.opc"
3812                 int dst AU = (op[1] >> 4) & 0x07;
3813 #line 307 "rx-decode.opc"
3814                 int sppp AU = op[1] & 0x0f;
3815                 if (trace)
3816                   {
3817                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3818                            "/** 0011 11sz d dst sppp            mov%s   #%1, %0 */",
3819                            op[0], op[1]);
3820                     printf ("  sz = 0x%x,", sz);
3821                     printf ("  d = 0x%x,", d);
3822                     printf ("  dst = 0x%x,", dst);
3823                     printf ("  sppp = 0x%x\n", sppp);
3824                   }
3825                 SYNTAX("mov%s   #%1, %0");
3826 #line 307 "rx-decode.opc"
3827                 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3828
3829               }
3830             break;
3831         }
3832       break;
3833     case 0x3d:
3834         GETBYTE ();
3835         switch (op[1] & 0x00)
3836         {
3837           case 0x00:
3838             goto op_semantics_20;
3839             break;
3840         }
3841       break;
3842     case 0x3e:
3843         GETBYTE ();
3844         switch (op[1] & 0x00)
3845         {
3846           case 0x00:
3847             goto op_semantics_20;
3848             break;
3849         }
3850       break;
3851     case 0x3f:
3852         GETBYTE ();
3853         switch (op[1] & 0x00)
3854         {
3855           case 0x00:
3856               {
3857                 /** 0011 1111 rega regb         rtsd    #%1, %2-%0 */
3858 #line 404 "rx-decode.opc"
3859                 int rega AU = (op[1] >> 4) & 0x0f;
3860 #line 404 "rx-decode.opc"
3861                 int regb AU = op[1] & 0x0f;
3862                 if (trace)
3863                   {
3864                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3865                            "/** 0011 1111 rega regb             rtsd    #%1, %2-%0 */",
3866                            op[0], op[1]);
3867                     printf ("  rega = 0x%x,", rega);
3868                     printf ("  regb = 0x%x\n", regb);
3869                   }
3870                 SYNTAX("rtsd    #%1, %2-%0");
3871 #line 404 "rx-decode.opc"
3872                 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3873
3874               /*----------------------------------------------------------------------*/
3875               /* AND                                                                    */
3876
3877               }
3878             break;
3879         }
3880       break;
3881     case 0x40:
3882         GETBYTE ();
3883         switch (op[1] & 0x00)
3884         {
3885           case 0x00:
3886             op_semantics_21:
3887               {
3888                 /** 0100 00ss rsrc rdst                 sub     %2%S2, %1 */
3889 #line 539 "rx-decode.opc"
3890                 int ss AU = op[0] & 0x03;
3891 #line 539 "rx-decode.opc"
3892                 int rsrc AU = (op[1] >> 4) & 0x0f;
3893 #line 539 "rx-decode.opc"
3894                 int rdst AU = op[1] & 0x0f;
3895                 if (trace)
3896                   {
3897                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3898                            "/** 0100 00ss rsrc rdst                     sub     %2%S2, %1 */",
3899                            op[0], op[1]);
3900                     printf ("  ss = 0x%x,", ss);
3901                     printf ("  rsrc = 0x%x,", rsrc);
3902                     printf ("  rdst = 0x%x\n", rdst);
3903                   }
3904                 SYNTAX("sub     %2%S2, %1");
3905 #line 539 "rx-decode.opc"
3906                 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3907
3908               }
3909             break;
3910         }
3911       break;
3912     case 0x41:
3913         GETBYTE ();
3914         switch (op[1] & 0x00)
3915         {
3916           case 0x00:
3917             goto op_semantics_21;
3918             break;
3919         }
3920       break;
3921     case 0x42:
3922         GETBYTE ();
3923         switch (op[1] & 0x00)
3924         {
3925           case 0x00:
3926             goto op_semantics_21;
3927             break;
3928         }
3929       break;
3930     case 0x43:
3931         GETBYTE ();
3932         switch (op[1] & 0x00)
3933         {
3934           case 0x00:
3935             goto op_semantics_21;
3936             break;
3937         }
3938       break;
3939     case 0x44:
3940         GETBYTE ();
3941         switch (op[1] & 0x00)
3942         {
3943           case 0x00:
3944             op_semantics_22:
3945               {
3946                 /** 0100 01ss rsrc rdst         cmp     %2%S2, %1 */
3947 #line 527 "rx-decode.opc"
3948                 int ss AU = op[0] & 0x03;
3949 #line 527 "rx-decode.opc"
3950                 int rsrc AU = (op[1] >> 4) & 0x0f;
3951 #line 527 "rx-decode.opc"
3952                 int rdst AU = op[1] & 0x0f;
3953                 if (trace)
3954                   {
3955                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3956                            "/** 0100 01ss rsrc rdst             cmp     %2%S2, %1 */",
3957                            op[0], op[1]);
3958                     printf ("  ss = 0x%x,", ss);
3959                     printf ("  rsrc = 0x%x,", rsrc);
3960                     printf ("  rdst = 0x%x\n", rdst);
3961                   }
3962                 SYNTAX("cmp     %2%S2, %1");
3963 #line 527 "rx-decode.opc"
3964                 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3965
3966               }
3967             break;
3968         }
3969       break;
3970     case 0x45:
3971         GETBYTE ();
3972         switch (op[1] & 0x00)
3973         {
3974           case 0x00:
3975             goto op_semantics_22;
3976             break;
3977         }
3978       break;
3979     case 0x46:
3980         GETBYTE ();
3981         switch (op[1] & 0x00)
3982         {
3983           case 0x00:
3984             goto op_semantics_22;
3985             break;
3986         }
3987       break;
3988     case 0x47:
3989         GETBYTE ();
3990         switch (op[1] & 0x00)
3991         {
3992           case 0x00:
3993             goto op_semantics_22;
3994             break;
3995         }
3996       break;
3997     case 0x48:
3998         GETBYTE ();
3999         switch (op[1] & 0x00)
4000         {
4001           case 0x00:
4002             op_semantics_23:
4003               {
4004                 /** 0100 10ss rsrc rdst                 add     %1%S1, %0 */
4005 #line 503 "rx-decode.opc"
4006                 int ss AU = op[0] & 0x03;
4007 #line 503 "rx-decode.opc"
4008                 int rsrc AU = (op[1] >> 4) & 0x0f;
4009 #line 503 "rx-decode.opc"
4010                 int rdst AU = op[1] & 0x0f;
4011                 if (trace)
4012                   {
4013                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4014                            "/** 0100 10ss rsrc rdst                     add     %1%S1, %0 */",
4015                            op[0], op[1]);
4016                     printf ("  ss = 0x%x,", ss);
4017                     printf ("  rsrc = 0x%x,", rsrc);
4018                     printf ("  rdst = 0x%x\n", rdst);
4019                   }
4020                 SYNTAX("add     %1%S1, %0");
4021 #line 503 "rx-decode.opc"
4022                 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
4023
4024               }
4025             break;
4026         }
4027       break;
4028     case 0x49:
4029         GETBYTE ();
4030         switch (op[1] & 0x00)
4031         {
4032           case 0x00:
4033             goto op_semantics_23;
4034             break;
4035         }
4036       break;
4037     case 0x4a:
4038         GETBYTE ();
4039         switch (op[1] & 0x00)
4040         {
4041           case 0x00:
4042             goto op_semantics_23;
4043             break;
4044         }
4045       break;
4046     case 0x4b:
4047         GETBYTE ();
4048         switch (op[1] & 0x00)
4049         {
4050           case 0x00:
4051             goto op_semantics_23;
4052             break;
4053         }
4054       break;
4055     case 0x4c:
4056         GETBYTE ();
4057         switch (op[1] & 0x00)
4058         {
4059           case 0x00:
4060             op_semantics_24:
4061               {
4062                 /** 0100 11ss rsrc rdst                 mul     %1%S1, %0 */
4063 #line 646 "rx-decode.opc"
4064                 int ss AU = op[0] & 0x03;
4065 #line 646 "rx-decode.opc"
4066                 int rsrc AU = (op[1] >> 4) & 0x0f;
4067 #line 646 "rx-decode.opc"
4068                 int rdst AU = op[1] & 0x0f;
4069                 if (trace)
4070                   {
4071                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4072                            "/** 0100 11ss rsrc rdst                     mul     %1%S1, %0 */",
4073                            op[0], op[1]);
4074                     printf ("  ss = 0x%x,", ss);
4075                     printf ("  rsrc = 0x%x,", rsrc);
4076                     printf ("  rdst = 0x%x\n", rdst);
4077                   }
4078                 SYNTAX("mul     %1%S1, %0");
4079 #line 646 "rx-decode.opc"
4080                 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
4081
4082               }
4083             break;
4084         }
4085       break;
4086     case 0x4d:
4087         GETBYTE ();
4088         switch (op[1] & 0x00)
4089         {
4090           case 0x00:
4091             goto op_semantics_24;
4092             break;
4093         }
4094       break;
4095     case 0x4e:
4096         GETBYTE ();
4097         switch (op[1] & 0x00)
4098         {
4099           case 0x00:
4100             goto op_semantics_24;
4101             break;
4102         }
4103       break;
4104     case 0x4f:
4105         GETBYTE ();
4106         switch (op[1] & 0x00)
4107         {
4108           case 0x00:
4109             goto op_semantics_24;
4110             break;
4111         }
4112       break;
4113     case 0x50:
4114         GETBYTE ();
4115         switch (op[1] & 0x00)
4116         {
4117           case 0x00:
4118             op_semantics_25:
4119               {
4120                 /** 0101 00ss rsrc rdst                 and     %1%S1, %0 */
4121 #line 416 "rx-decode.opc"
4122                 int ss AU = op[0] & 0x03;
4123 #line 416 "rx-decode.opc"
4124                 int rsrc AU = (op[1] >> 4) & 0x0f;
4125 #line 416 "rx-decode.opc"
4126                 int rdst AU = op[1] & 0x0f;
4127                 if (trace)
4128                   {
4129                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4130                            "/** 0101 00ss rsrc rdst                     and     %1%S1, %0 */",
4131                            op[0], op[1]);
4132                     printf ("  ss = 0x%x,", ss);
4133                     printf ("  rsrc = 0x%x,", rsrc);
4134                     printf ("  rdst = 0x%x\n", rdst);
4135                   }
4136                 SYNTAX("and     %1%S1, %0");
4137 #line 416 "rx-decode.opc"
4138                 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
4139
4140               }
4141             break;
4142         }
4143       break;
4144     case 0x51:
4145         GETBYTE ();
4146         switch (op[1] & 0x00)
4147         {
4148           case 0x00:
4149             goto op_semantics_25;
4150             break;
4151         }
4152       break;
4153     case 0x52:
4154         GETBYTE ();
4155         switch (op[1] & 0x00)
4156         {
4157           case 0x00:
4158             goto op_semantics_25;
4159             break;
4160         }
4161       break;
4162     case 0x53:
4163         GETBYTE ();
4164         switch (op[1] & 0x00)
4165         {
4166           case 0x00:
4167             goto op_semantics_25;
4168             break;
4169         }
4170       break;
4171     case 0x54:
4172         GETBYTE ();
4173         switch (op[1] & 0x00)
4174         {
4175           case 0x00:
4176             op_semantics_26:
4177               {
4178                 /** 0101 01ss rsrc rdst                 or      %1%S1, %0 */
4179 #line 434 "rx-decode.opc"
4180                 int ss AU = op[0] & 0x03;
4181 #line 434 "rx-decode.opc"
4182                 int rsrc AU = (op[1] >> 4) & 0x0f;
4183 #line 434 "rx-decode.opc"
4184                 int rdst AU = op[1] & 0x0f;
4185                 if (trace)
4186                   {
4187                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4188                            "/** 0101 01ss rsrc rdst                     or      %1%S1, %0 */",
4189                            op[0], op[1]);
4190                     printf ("  ss = 0x%x,", ss);
4191                     printf ("  rsrc = 0x%x,", rsrc);
4192                     printf ("  rdst = 0x%x\n", rdst);
4193                   }
4194                 SYNTAX("or      %1%S1, %0");
4195 #line 434 "rx-decode.opc"
4196                 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4197
4198               }
4199             break;
4200         }
4201       break;
4202     case 0x55:
4203         GETBYTE ();
4204         switch (op[1] & 0x00)
4205         {
4206           case 0x00:
4207             goto op_semantics_26;
4208             break;
4209         }
4210       break;
4211     case 0x56:
4212         GETBYTE ();
4213         switch (op[1] & 0x00)
4214         {
4215           case 0x00:
4216             goto op_semantics_26;
4217             break;
4218         }
4219       break;
4220     case 0x57:
4221         GETBYTE ();
4222         switch (op[1] & 0x00)
4223         {
4224           case 0x00:
4225             goto op_semantics_26;
4226             break;
4227         }
4228       break;
4229     case 0x58:
4230         GETBYTE ();
4231         switch (op[1] & 0x00)
4232         {
4233           case 0x00:
4234             op_semantics_27:
4235               {
4236                 /** 0101 1 s ss rsrc rdst       movu%s  %1, %0 */
4237 #line 355 "rx-decode.opc"
4238                 int s AU = (op[0] >> 2) & 0x01;
4239 #line 355 "rx-decode.opc"
4240                 int ss AU = op[0] & 0x03;
4241 #line 355 "rx-decode.opc"
4242                 int rsrc AU = (op[1] >> 4) & 0x0f;
4243 #line 355 "rx-decode.opc"
4244                 int rdst AU = op[1] & 0x0f;
4245                 if (trace)
4246                   {
4247                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4248                            "/** 0101 1 s ss rsrc rdst   movu%s  %1, %0 */",
4249                            op[0], op[1]);
4250                     printf ("  s = 0x%x,", s);
4251                     printf ("  ss = 0x%x,", ss);
4252                     printf ("  rsrc = 0x%x,", rsrc);
4253                     printf ("  rdst = 0x%x\n", rdst);
4254                   }
4255                 SYNTAX("movu%s  %1, %0");
4256 #line 355 "rx-decode.opc"
4257                 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
4258
4259               }
4260             break;
4261         }
4262       break;
4263     case 0x59:
4264         GETBYTE ();
4265         switch (op[1] & 0x00)
4266         {
4267           case 0x00:
4268             goto op_semantics_27;
4269             break;
4270         }
4271       break;
4272     case 0x5a:
4273         GETBYTE ();
4274         switch (op[1] & 0x00)
4275         {
4276           case 0x00:
4277             goto op_semantics_27;
4278             break;
4279         }
4280       break;
4281     case 0x5b:
4282         GETBYTE ();
4283         switch (op[1] & 0x00)
4284         {
4285           case 0x00:
4286             goto op_semantics_27;
4287             break;
4288         }
4289       break;
4290     case 0x5c:
4291         GETBYTE ();
4292         switch (op[1] & 0x00)
4293         {
4294           case 0x00:
4295             goto op_semantics_27;
4296             break;
4297         }
4298       break;
4299     case 0x5d:
4300         GETBYTE ();
4301         switch (op[1] & 0x00)
4302         {
4303           case 0x00:
4304             goto op_semantics_27;
4305             break;
4306         }
4307       break;
4308     case 0x5e:
4309         GETBYTE ();
4310         switch (op[1] & 0x00)
4311         {
4312           case 0x00:
4313             goto op_semantics_27;
4314             break;
4315         }
4316       break;
4317     case 0x5f:
4318         GETBYTE ();
4319         switch (op[1] & 0x00)
4320         {
4321           case 0x00:
4322             goto op_semantics_27;
4323             break;
4324         }
4325       break;
4326     case 0x60:
4327         GETBYTE ();
4328         switch (op[1] & 0x00)
4329         {
4330           case 0x00:
4331               {
4332                 /** 0110 0000 immm rdst                 sub     #%2, %0 */
4333 #line 536 "rx-decode.opc"
4334                 int immm AU = (op[1] >> 4) & 0x0f;
4335 #line 536 "rx-decode.opc"
4336                 int rdst AU = op[1] & 0x0f;
4337                 if (trace)
4338                   {
4339                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4340                            "/** 0110 0000 immm rdst                     sub     #%2, %0 */",
4341                            op[0], op[1]);
4342                     printf ("  immm = 0x%x,", immm);
4343                     printf ("  rdst = 0x%x\n", rdst);
4344                   }
4345                 SYNTAX("sub     #%2, %0");
4346 #line 536 "rx-decode.opc"
4347                 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4348
4349               }
4350             break;
4351         }
4352       break;
4353     case 0x61:
4354         GETBYTE ();
4355         switch (op[1] & 0x00)
4356         {
4357           case 0x00:
4358               {
4359                 /** 0110 0001 immm rdst                 cmp     #%2, %1 */
4360 #line 518 "rx-decode.opc"
4361                 int immm AU = (op[1] >> 4) & 0x0f;
4362 #line 518 "rx-decode.opc"
4363                 int rdst AU = op[1] & 0x0f;
4364                 if (trace)
4365                   {
4366                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4367                            "/** 0110 0001 immm rdst                     cmp     #%2, %1 */",
4368                            op[0], op[1]);
4369                     printf ("  immm = 0x%x,", immm);
4370                     printf ("  rdst = 0x%x\n", rdst);
4371                   }
4372                 SYNTAX("cmp     #%2, %1");
4373 #line 518 "rx-decode.opc"
4374                 ID(sub); S2C(immm); SR(rdst); F_OSZC;
4375
4376               }
4377             break;
4378         }
4379       break;
4380     case 0x62:
4381         GETBYTE ();
4382         switch (op[1] & 0x00)
4383         {
4384           case 0x00:
4385               {
4386                 /** 0110 0010 immm rdst                 add     #%1, %0 */
4387 #line 500 "rx-decode.opc"
4388                 int immm AU = (op[1] >> 4) & 0x0f;
4389 #line 500 "rx-decode.opc"
4390                 int rdst AU = op[1] & 0x0f;
4391                 if (trace)
4392                   {
4393                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4394                            "/** 0110 0010 immm rdst                     add     #%1, %0 */",
4395                            op[0], op[1]);
4396                     printf ("  immm = 0x%x,", immm);
4397                     printf ("  rdst = 0x%x\n", rdst);
4398                   }
4399                 SYNTAX("add     #%1, %0");
4400 #line 500 "rx-decode.opc"
4401                 ID(add); SC(immm); DR(rdst); F_OSZC;
4402
4403               }
4404             break;
4405         }
4406       break;
4407     case 0x63:
4408         GETBYTE ();
4409         switch (op[1] & 0x00)
4410         {
4411           case 0x00:
4412               {
4413                 /** 0110 0011 immm rdst                 mul     #%1, %0 */
4414 #line 612 "rx-decode.opc"
4415                 int immm AU = (op[1] >> 4) & 0x0f;
4416 #line 612 "rx-decode.opc"
4417                 int rdst AU = op[1] & 0x0f;
4418                 if (trace)
4419                   {
4420                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4421                            "/** 0110 0011 immm rdst                     mul     #%1, %0 */",
4422                            op[0], op[1]);
4423                     printf ("  immm = 0x%x,", immm);
4424                     printf ("  rdst = 0x%x\n", rdst);
4425                   }
4426                 SYNTAX("mul     #%1, %0");
4427 #line 612 "rx-decode.opc"
4428                 if (immm == 1 && rdst == 0)
4429                   {
4430                     ID(nop2);
4431                     SYNTAX ("nop\t; mul\t#1, r0");
4432                   }
4433                 else
4434                   {
4435                     ID(mul);
4436                   }
4437                 DR(rdst); SC(immm); F_____;
4438
4439               }
4440             break;
4441         }
4442       break;
4443     case 0x64:
4444         GETBYTE ();
4445         switch (op[1] & 0x00)
4446         {
4447           case 0x00:
4448               {
4449                 /** 0110 0100 immm rdst                 and     #%1, %0 */
4450 #line 410 "rx-decode.opc"
4451                 int immm AU = (op[1] >> 4) & 0x0f;
4452 #line 410 "rx-decode.opc"
4453                 int rdst AU = op[1] & 0x0f;
4454                 if (trace)
4455                   {
4456                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4457                            "/** 0110 0100 immm rdst                     and     #%1, %0 */",
4458                            op[0], op[1]);
4459                     printf ("  immm = 0x%x,", immm);
4460                     printf ("  rdst = 0x%x\n", rdst);
4461                   }
4462                 SYNTAX("and     #%1, %0");
4463 #line 410 "rx-decode.opc"
4464                 ID(and); SC(immm); DR(rdst); F__SZ_;
4465
4466               }
4467             break;
4468         }
4469       break;
4470     case 0x65:
4471         GETBYTE ();
4472         switch (op[1] & 0x00)
4473         {
4474           case 0x00:
4475               {
4476                 /** 0110 0101 immm rdst                 or      #%1, %0 */
4477 #line 428 "rx-decode.opc"
4478                 int immm AU = (op[1] >> 4) & 0x0f;
4479 #line 428 "rx-decode.opc"
4480                 int rdst AU = op[1] & 0x0f;
4481                 if (trace)
4482                   {
4483                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4484                            "/** 0110 0101 immm rdst                     or      #%1, %0 */",
4485                            op[0], op[1]);
4486                     printf ("  immm = 0x%x,", immm);
4487                     printf ("  rdst = 0x%x\n", rdst);
4488                   }
4489                 SYNTAX("or      #%1, %0");
4490 #line 428 "rx-decode.opc"
4491                 ID(or); SC(immm); DR(rdst); F__SZ_;
4492
4493               }
4494             break;
4495         }
4496       break;
4497     case 0x66:
4498         GETBYTE ();
4499         switch (op[1] & 0x00)
4500         {
4501           case 0x00:
4502               {
4503                 /** 0110 0110 immm rdst         mov%s   #%1, %0 */
4504 #line 304 "rx-decode.opc"
4505                 int immm AU = (op[1] >> 4) & 0x0f;
4506 #line 304 "rx-decode.opc"
4507                 int rdst AU = op[1] & 0x0f;
4508                 if (trace)
4509                   {
4510                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4511                            "/** 0110 0110 immm rdst             mov%s   #%1, %0 */",
4512                            op[0], op[1]);
4513                     printf ("  immm = 0x%x,", immm);
4514                     printf ("  rdst = 0x%x\n", rdst);
4515                   }
4516                 SYNTAX("mov%s   #%1, %0");
4517 #line 304 "rx-decode.opc"
4518                 ID(mov); DR(rdst); SC(immm); F_____;
4519
4520               }
4521             break;
4522         }
4523       break;
4524     case 0x67:
4525         {
4526           /** 0110 0111                 rtsd    #%1 */
4527           if (trace)
4528             {
4529               printf ("\033[33m%s\033[0m  %02x\n",
4530                      "/** 0110 0111                     rtsd    #%1 */",
4531                      op[0]);
4532             }
4533           SYNTAX("rtsd  #%1");
4534 #line 401 "rx-decode.opc"
4535           ID(rtsd); SC(IMM(1) * 4);
4536
4537         }
4538       break;
4539     case 0x68:
4540         GETBYTE ();
4541         switch (op[1] & 0x00)
4542         {
4543           case 0x00:
4544             op_semantics_28:
4545               {
4546                 /** 0110 100i mmmm rdst                 shlr    #%2, %0 */
4547 #line 726 "rx-decode.opc"
4548                 int i AU = op[0] & 0x01;
4549 #line 726 "rx-decode.opc"
4550                 int mmmm AU = (op[1] >> 4) & 0x0f;
4551 #line 726 "rx-decode.opc"
4552                 int rdst AU = op[1] & 0x0f;
4553                 if (trace)
4554                   {
4555                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4556                            "/** 0110 100i mmmm rdst                     shlr    #%2, %0 */",
4557                            op[0], op[1]);
4558                     printf ("  i = 0x%x,", i);
4559                     printf ("  mmmm = 0x%x,", mmmm);
4560                     printf ("  rdst = 0x%x\n", rdst);
4561                   }
4562                 SYNTAX("shlr    #%2, %0");
4563 #line 726 "rx-decode.opc"
4564                 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4565
4566               }
4567             break;
4568         }
4569       break;
4570     case 0x69:
4571         GETBYTE ();
4572         switch (op[1] & 0x00)
4573         {
4574           case 0x00:
4575             goto op_semantics_28;
4576             break;
4577         }
4578       break;
4579     case 0x6a:
4580         GETBYTE ();
4581         switch (op[1] & 0x00)
4582         {
4583           case 0x00:
4584             op_semantics_29:
4585               {
4586                 /** 0110 101i mmmm rdst                 shar    #%2, %0 */
4587 #line 716 "rx-decode.opc"
4588                 int i AU = op[0] & 0x01;
4589 #line 716 "rx-decode.opc"
4590                 int mmmm AU = (op[1] >> 4) & 0x0f;
4591 #line 716 "rx-decode.opc"
4592                 int rdst AU = op[1] & 0x0f;
4593                 if (trace)
4594                   {
4595                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4596                            "/** 0110 101i mmmm rdst                     shar    #%2, %0 */",
4597                            op[0], op[1]);
4598                     printf ("  i = 0x%x,", i);
4599                     printf ("  mmmm = 0x%x,", mmmm);
4600                     printf ("  rdst = 0x%x\n", rdst);
4601                   }
4602                 SYNTAX("shar    #%2, %0");
4603 #line 716 "rx-decode.opc"
4604                 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4605
4606               }
4607             break;
4608         }
4609       break;
4610     case 0x6b:
4611         GETBYTE ();
4612         switch (op[1] & 0x00)
4613         {
4614           case 0x00:
4615             goto op_semantics_29;
4616             break;
4617         }
4618       break;
4619     case 0x6c:
4620         GETBYTE ();
4621         switch (op[1] & 0x00)
4622         {
4623           case 0x00:
4624             op_semantics_30:
4625               {
4626                 /** 0110 110i mmmm rdst                 shll    #%2, %0 */
4627 #line 706 "rx-decode.opc"
4628                 int i AU = op[0] & 0x01;
4629 #line 706 "rx-decode.opc"
4630                 int mmmm AU = (op[1] >> 4) & 0x0f;
4631 #line 706 "rx-decode.opc"
4632                 int rdst AU = op[1] & 0x0f;
4633                 if (trace)
4634                   {
4635                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4636                            "/** 0110 110i mmmm rdst                     shll    #%2, %0 */",
4637                            op[0], op[1]);
4638                     printf ("  i = 0x%x,", i);
4639                     printf ("  mmmm = 0x%x,", mmmm);
4640                     printf ("  rdst = 0x%x\n", rdst);
4641                   }
4642                 SYNTAX("shll    #%2, %0");
4643 #line 706 "rx-decode.opc"
4644                 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4645
4646               }
4647             break;
4648         }
4649       break;
4650     case 0x6d:
4651         GETBYTE ();
4652         switch (op[1] & 0x00)
4653         {
4654           case 0x00:
4655             goto op_semantics_30;
4656             break;
4657         }
4658       break;
4659     case 0x6e:
4660         GETBYTE ();
4661         switch (op[1] & 0x00)
4662         {
4663           case 0x00:
4664               {
4665                 /** 0110 1110 dsta dstb         pushm   %1-%2 */
4666 #line 368 "rx-decode.opc"
4667                 int dsta AU = (op[1] >> 4) & 0x0f;
4668 #line 368 "rx-decode.opc"
4669                 int dstb AU = op[1] & 0x0f;
4670                 if (trace)
4671                   {
4672                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4673                            "/** 0110 1110 dsta dstb             pushm   %1-%2 */",
4674                            op[0], op[1]);
4675                     printf ("  dsta = 0x%x,", dsta);
4676                     printf ("  dstb = 0x%x\n", dstb);
4677                   }
4678                 SYNTAX("pushm   %1-%2");
4679 #line 368 "rx-decode.opc"
4680                 ID(pushm); SR(dsta); S2R(dstb); F_____;
4681
4682               }
4683             break;
4684         }
4685       break;
4686     case 0x6f:
4687         GETBYTE ();
4688         switch (op[1] & 0x00)
4689         {
4690           case 0x00:
4691               {
4692                 /** 0110 1111 dsta dstb         popm    %1-%2 */
4693 #line 365 "rx-decode.opc"
4694                 int dsta AU = (op[1] >> 4) & 0x0f;
4695 #line 365 "rx-decode.opc"
4696                 int dstb AU = op[1] & 0x0f;
4697                 if (trace)
4698                   {
4699                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4700                            "/** 0110 1111 dsta dstb             popm    %1-%2 */",
4701                            op[0], op[1]);
4702                     printf ("  dsta = 0x%x,", dsta);
4703                     printf ("  dstb = 0x%x\n", dstb);
4704                   }
4705                 SYNTAX("popm    %1-%2");
4706 #line 365 "rx-decode.opc"
4707                 ID(popm); SR(dsta); S2R(dstb); F_____;
4708
4709               }
4710             break;
4711         }
4712       break;
4713     case 0x70:
4714         GETBYTE ();
4715         switch (op[1] & 0x00)
4716         {
4717           case 0x00:
4718             op_semantics_31:
4719               {
4720                 /** 0111 00im rsrc rdst                 add     #%1, %2, %0 */
4721 #line 509 "rx-decode.opc"
4722                 int im AU = op[0] & 0x03;
4723 #line 509 "rx-decode.opc"
4724                 int rsrc AU = (op[1] >> 4) & 0x0f;
4725 #line 509 "rx-decode.opc"
4726                 int rdst AU = op[1] & 0x0f;
4727                 if (trace)
4728                   {
4729                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4730                            "/** 0111 00im rsrc rdst                     add     #%1, %2, %0 */",
4731                            op[0], op[1]);
4732                     printf ("  im = 0x%x,", im);
4733                     printf ("  rsrc = 0x%x,", rsrc);
4734                     printf ("  rdst = 0x%x\n", rdst);
4735                   }
4736                 SYNTAX("add     #%1, %2, %0");
4737 #line 509 "rx-decode.opc"
4738                 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4739
4740               }
4741             break;
4742         }
4743       break;
4744     case 0x71:
4745         GETBYTE ();
4746         switch (op[1] & 0x00)
4747         {
4748           case 0x00:
4749             goto op_semantics_31;
4750             break;
4751         }
4752       break;
4753     case 0x72:
4754         GETBYTE ();
4755         switch (op[1] & 0x00)
4756         {
4757           case 0x00:
4758             goto op_semantics_31;
4759             break;
4760         }
4761       break;
4762     case 0x73:
4763         GETBYTE ();
4764         switch (op[1] & 0x00)
4765         {
4766           case 0x00:
4767             goto op_semantics_31;
4768             break;
4769         }
4770       break;
4771     case 0x74:
4772         GETBYTE ();
4773         switch (op[1] & 0xf0)
4774         {
4775           case 0x00:
4776             op_semantics_32:
4777               {
4778                 /** 0111 01im 0000 rsrc         cmp     #%2, %1%S1 */
4779 #line 521 "rx-decode.opc"
4780                 int im AU = op[0] & 0x03;
4781 #line 521 "rx-decode.opc"
4782                 int rsrc AU = op[1] & 0x0f;
4783                 if (trace)
4784                   {
4785                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4786                            "/** 0111 01im 0000 rsrc             cmp     #%2, %1%S1 */",
4787                            op[0], op[1]);
4788                     printf ("  im = 0x%x,", im);
4789                     printf ("  rsrc = 0x%x\n", rsrc);
4790                   }
4791                 SYNTAX("cmp     #%2, %1%S1");
4792 #line 521 "rx-decode.opc"
4793                 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4794
4795               }
4796             break;
4797           case 0x10:
4798             op_semantics_33:
4799               {
4800                 /** 0111 01im 0001rdst                  mul     #%1, %0 */
4801 #line 624 "rx-decode.opc"
4802                 int im AU = op[0] & 0x03;
4803 #line 624 "rx-decode.opc"
4804                 int rdst AU = op[1] & 0x0f;
4805                 if (trace)
4806                   {
4807                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4808                            "/** 0111 01im 0001rdst                      mul     #%1, %0 */",
4809                            op[0], op[1]);
4810                     printf ("  im = 0x%x,", im);
4811                     printf ("  rdst = 0x%x\n", rdst);
4812                   }
4813                 SYNTAX("mul     #%1, %0");
4814 #line 624 "rx-decode.opc"
4815                 int val = IMMex(im);
4816                 if (val == 1 && rdst == 0)
4817                   {
4818                     SYNTAX("nop\t; mul\t#1, r0");
4819                     switch (im)
4820                 {
4821                 case 2: ID(nop4); break;
4822                 case 3: ID(nop5); break;
4823                 case 0: ID(nop6); break;
4824                 default:
4825                   ID(mul);
4826                   SYNTAX("mul   #%1, %0");
4827                   break;
4828                 }
4829                   }
4830                 else
4831                   {
4832                     ID(mul);
4833                   }
4834                 DR(rdst); SC(val); F_____;
4835
4836               }
4837             break;
4838           case 0x20:
4839             op_semantics_34:
4840               {
4841                 /** 0111 01im 0010 rdst                 and     #%1, %0 */
4842 #line 413 "rx-decode.opc"
4843                 int im AU = op[0] & 0x03;
4844 #line 413 "rx-decode.opc"
4845                 int rdst AU = op[1] & 0x0f;
4846                 if (trace)
4847                   {
4848                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4849                            "/** 0111 01im 0010 rdst                     and     #%1, %0 */",
4850                            op[0], op[1]);
4851                     printf ("  im = 0x%x,", im);
4852                     printf ("  rdst = 0x%x\n", rdst);
4853                   }
4854                 SYNTAX("and     #%1, %0");
4855 #line 413 "rx-decode.opc"
4856                 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4857
4858               }
4859             break;
4860           case 0x30:
4861             op_semantics_35:
4862               {
4863                 /** 0111 01im 0011 rdst                 or      #%1, %0 */
4864 #line 431 "rx-decode.opc"
4865                 int im AU = op[0] & 0x03;
4866 #line 431 "rx-decode.opc"
4867                 int rdst AU = op[1] & 0x0f;
4868                 if (trace)
4869                   {
4870                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4871                            "/** 0111 01im 0011 rdst                     or      #%1, %0 */",
4872                            op[0], op[1]);
4873                     printf ("  im = 0x%x,", im);
4874                     printf ("  rdst = 0x%x\n", rdst);
4875                   }
4876                 SYNTAX("or      #%1, %0");
4877 #line 431 "rx-decode.opc"
4878                 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4879
4880               }
4881             break;
4882           default: UNSUPPORTED(); break;
4883         }
4884       break;
4885     case 0x75:
4886         GETBYTE ();
4887         switch (op[1] & 0xff)
4888         {
4889           case 0x00:
4890           case 0x01:
4891           case 0x02:
4892           case 0x03:
4893           case 0x04:
4894           case 0x05:
4895           case 0x06:
4896           case 0x07:
4897           case 0x08:
4898           case 0x09:
4899           case 0x0a:
4900           case 0x0b:
4901           case 0x0c:
4902           case 0x0d:
4903           case 0x0e:
4904           case 0x0f:
4905             goto op_semantics_32;
4906             break;
4907           case 0x10:
4908           case 0x11:
4909           case 0x12:
4910           case 0x13:
4911           case 0x14:
4912           case 0x15:
4913           case 0x16:
4914           case 0x17:
4915           case 0x18:
4916           case 0x19:
4917           case 0x1a:
4918           case 0x1b:
4919           case 0x1c:
4920           case 0x1d:
4921           case 0x1e:
4922           case 0x1f:
4923             goto op_semantics_33;
4924             break;
4925           case 0x20:
4926           case 0x21:
4927           case 0x22:
4928           case 0x23:
4929           case 0x24:
4930           case 0x25:
4931           case 0x26:
4932           case 0x27:
4933           case 0x28:
4934           case 0x29:
4935           case 0x2a:
4936           case 0x2b:
4937           case 0x2c:
4938           case 0x2d:
4939           case 0x2e:
4940           case 0x2f:
4941             goto op_semantics_34;
4942             break;
4943           case 0x30:
4944           case 0x31:
4945           case 0x32:
4946           case 0x33:
4947           case 0x34:
4948           case 0x35:
4949           case 0x36:
4950           case 0x37:
4951           case 0x38:
4952           case 0x39:
4953           case 0x3a:
4954           case 0x3b:
4955           case 0x3c:
4956           case 0x3d:
4957           case 0x3e:
4958           case 0x3f:
4959             goto op_semantics_35;
4960             break;
4961           case 0x40:
4962           case 0x41:
4963           case 0x42:
4964           case 0x43:
4965           case 0x44:
4966           case 0x45:
4967           case 0x46:
4968           case 0x47:
4969           case 0x48:
4970           case 0x49:
4971           case 0x4a:
4972           case 0x4b:
4973           case 0x4c:
4974           case 0x4d:
4975           case 0x4e:
4976           case 0x4f:
4977               {
4978                 /** 0111 0101 0100 rdst         mov%s   #%1, %0 */
4979 #line 285 "rx-decode.opc"
4980                 int rdst AU = op[1] & 0x0f;
4981                 if (trace)
4982                   {
4983                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4984                            "/** 0111 0101 0100 rdst             mov%s   #%1, %0 */",
4985                            op[0], op[1]);
4986                     printf ("  rdst = 0x%x\n", rdst);
4987                   }
4988                 SYNTAX("mov%s   #%1, %0");
4989 #line 285 "rx-decode.opc"
4990                 ID(mov); DR(rdst); SC(IMM (1)); F_____;
4991
4992               }
4993             break;
4994           case 0x50:
4995           case 0x51:
4996           case 0x52:
4997           case 0x53:
4998           case 0x54:
4999           case 0x55:
5000           case 0x56:
5001           case 0x57:
5002           case 0x58:
5003           case 0x59:
5004           case 0x5a:
5005           case 0x5b:
5006           case 0x5c:
5007           case 0x5d:
5008           case 0x5e:
5009           case 0x5f:
5010               {
5011                 /** 0111 0101 0101 rsrc                 cmp     #%2, %1 */
5012 #line 524 "rx-decode.opc"
5013                 int rsrc AU = op[1] & 0x0f;
5014                 if (trace)
5015                   {
5016                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5017                            "/** 0111 0101 0101 rsrc                     cmp     #%2, %1 */",
5018                            op[0], op[1]);
5019                     printf ("  rsrc = 0x%x\n", rsrc);
5020                   }
5021                 SYNTAX("cmp     #%2, %1");
5022 #line 524 "rx-decode.opc"
5023                 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
5024
5025               }
5026             break;
5027           case 0x60:
5028               {
5029                 /** 0111 0101 0110 0000         int #%1 */
5030                 if (trace)
5031                   {
5032                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5033                            "/** 0111 0101 0110 0000             int #%1 */",
5034                            op[0], op[1]);
5035                   }
5036                 SYNTAX("int #%1");
5037 #line 1031 "rx-decode.opc"
5038                 ID(int); SC(IMM(1));
5039
5040               }
5041             break;
5042           case 0x70:
5043               GETBYTE ();
5044               switch (op[2] & 0xf0)
5045               {
5046                 case 0x00:
5047                     {
5048                       /** 0111 0101 0111 0000 0000 immm mvtipl  #%1 */
5049 #line 998 "rx-decode.opc"
5050                       int immm AU = op[2] & 0x0f;
5051                       if (trace)
5052                         {
5053                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5054                                  "/** 0111 0101 0111 0000 0000 immm     mvtipl  #%1 */",
5055                                  op[0], op[1], op[2]);
5056                           printf ("  immm = 0x%x\n", immm);
5057                         }
5058                       SYNTAX("mvtipl    #%1");
5059 #line 998 "rx-decode.opc"
5060                       ID(mvtipl); SC(immm);
5061
5062                     }
5063                   break;
5064                 default: UNSUPPORTED(); break;
5065               }
5066             break;
5067           default: UNSUPPORTED(); break;
5068         }
5069       break;
5070     case 0x76:
5071         GETBYTE ();
5072         switch (op[1] & 0xf0)
5073         {
5074           case 0x00:
5075             goto op_semantics_32;
5076             break;
5077           case 0x10:
5078             goto op_semantics_33;
5079             break;
5080           case 0x20:
5081             goto op_semantics_34;
5082             break;
5083           case 0x30:
5084             goto op_semantics_35;
5085             break;
5086           default: UNSUPPORTED(); break;
5087         }
5088       break;
5089     case 0x77:
5090         GETBYTE ();
5091         switch (op[1] & 0xf0)
5092         {
5093           case 0x00:
5094             goto op_semantics_32;
5095             break;
5096           case 0x10:
5097             goto op_semantics_33;
5098             break;
5099           case 0x20:
5100             goto op_semantics_34;
5101             break;
5102           case 0x30:
5103             goto op_semantics_35;
5104             break;
5105           default: UNSUPPORTED(); break;
5106         }
5107       break;
5108     case 0x78:
5109         GETBYTE ();
5110         switch (op[1] & 0x00)
5111         {
5112           case 0x00:
5113             op_semantics_36:
5114               {
5115                 /** 0111 100b ittt rdst                 bset    #%1, %0 */
5116 #line 943 "rx-decode.opc"
5117                 int b AU = op[0] & 0x01;
5118 #line 943 "rx-decode.opc"
5119                 int ittt AU = (op[1] >> 4) & 0x0f;
5120 #line 943 "rx-decode.opc"
5121                 int rdst AU = op[1] & 0x0f;
5122                 if (trace)
5123                   {
5124                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5125                            "/** 0111 100b ittt rdst                     bset    #%1, %0 */",
5126                            op[0], op[1]);
5127                     printf ("  b = 0x%x,", b);
5128                     printf ("  ittt = 0x%x,", ittt);
5129                     printf ("  rdst = 0x%x\n", rdst);
5130                   }
5131                 SYNTAX("bset    #%1, %0");
5132 #line 943 "rx-decode.opc"
5133                 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5134
5135
5136               }
5137             break;
5138         }
5139       break;
5140     case 0x79:
5141         GETBYTE ();
5142         switch (op[1] & 0x00)
5143         {
5144           case 0x00:
5145             goto op_semantics_36;
5146             break;
5147         }
5148       break;
5149     case 0x7a:
5150         GETBYTE ();
5151         switch (op[1] & 0x00)
5152         {
5153           case 0x00:
5154             op_semantics_37:
5155               {
5156                 /** 0111 101b ittt rdst                 bclr    #%1, %0 */
5157 #line 955 "rx-decode.opc"
5158                 int b AU = op[0] & 0x01;
5159 #line 955 "rx-decode.opc"
5160                 int ittt AU = (op[1] >> 4) & 0x0f;
5161 #line 955 "rx-decode.opc"
5162                 int rdst AU = op[1] & 0x0f;
5163                 if (trace)
5164                   {
5165                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5166                            "/** 0111 101b ittt rdst                     bclr    #%1, %0 */",
5167                            op[0], op[1]);
5168                     printf ("  b = 0x%x,", b);
5169                     printf ("  ittt = 0x%x,", ittt);
5170                     printf ("  rdst = 0x%x\n", rdst);
5171                   }
5172                 SYNTAX("bclr    #%1, %0");
5173 #line 955 "rx-decode.opc"
5174                 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
5175
5176
5177               }
5178             break;
5179         }
5180       break;
5181     case 0x7b:
5182         GETBYTE ();
5183         switch (op[1] & 0x00)
5184         {
5185           case 0x00:
5186             goto op_semantics_37;
5187             break;
5188         }
5189       break;
5190     case 0x7c:
5191         GETBYTE ();
5192         switch (op[1] & 0x00)
5193         {
5194           case 0x00:
5195             op_semantics_38:
5196               {
5197                 /** 0111 110b ittt rdst                 btst    #%2, %1 */
5198 #line 967 "rx-decode.opc"
5199                 int b AU = op[0] & 0x01;
5200 #line 967 "rx-decode.opc"
5201                 int ittt AU = (op[1] >> 4) & 0x0f;
5202 #line 967 "rx-decode.opc"
5203                 int rdst AU = op[1] & 0x0f;
5204                 if (trace)
5205                   {
5206                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5207                            "/** 0111 110b ittt rdst                     btst    #%2, %1 */",
5208                            op[0], op[1]);
5209                     printf ("  b = 0x%x,", b);
5210                     printf ("  ittt = 0x%x,", ittt);
5211                     printf ("  rdst = 0x%x\n", rdst);
5212                   }
5213                 SYNTAX("btst    #%2, %1");
5214 #line 967 "rx-decode.opc"
5215                 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
5216
5217
5218               }
5219             break;
5220         }
5221       break;
5222     case 0x7d:
5223         GETBYTE ();
5224         switch (op[1] & 0x00)
5225         {
5226           case 0x00:
5227             goto op_semantics_38;
5228             break;
5229         }
5230       break;
5231     case 0x7e:
5232         GETBYTE ();
5233         switch (op[1] & 0xf0)
5234         {
5235           case 0x00:
5236               {
5237                 /** 0111 1110 0000 rdst                 not     %0 */
5238 #line 458 "rx-decode.opc"
5239                 int rdst AU = op[1] & 0x0f;
5240                 if (trace)
5241                   {
5242                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5243                            "/** 0111 1110 0000 rdst                     not     %0 */",
5244                            op[0], op[1]);
5245                     printf ("  rdst = 0x%x\n", rdst);
5246                   }
5247                 SYNTAX("not     %0");
5248 #line 458 "rx-decode.opc"
5249                 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
5250
5251               }
5252             break;
5253           case 0x10:
5254               {
5255                 /** 0111 1110 0001 rdst                 neg     %0 */
5256 #line 479 "rx-decode.opc"
5257                 int rdst AU = op[1] & 0x0f;
5258                 if (trace)
5259                   {
5260                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5261                            "/** 0111 1110 0001 rdst                     neg     %0 */",
5262                            op[0], op[1]);
5263                     printf ("  rdst = 0x%x\n", rdst);
5264                   }
5265                 SYNTAX("neg     %0");
5266 #line 479 "rx-decode.opc"
5267                 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
5268
5269               }
5270             break;
5271           case 0x20:
5272               {
5273                 /** 0111 1110 0010 rdst                 abs     %0 */
5274 #line 561 "rx-decode.opc"
5275                 int rdst AU = op[1] & 0x0f;
5276                 if (trace)
5277                   {
5278                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5279                            "/** 0111 1110 0010 rdst                     abs     %0 */",
5280                            op[0], op[1]);
5281                     printf ("  rdst = 0x%x\n", rdst);
5282                   }
5283                 SYNTAX("abs     %0");
5284 #line 561 "rx-decode.opc"
5285                 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
5286
5287               }
5288             break;
5289           case 0x30:
5290               {
5291                 /** 0111 1110 0011 rdst         sat     %0 */
5292 #line 881 "rx-decode.opc"
5293                 int rdst AU = op[1] & 0x0f;
5294                 if (trace)
5295                   {
5296                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5297                            "/** 0111 1110 0011 rdst             sat     %0 */",
5298                            op[0], op[1]);
5299                     printf ("  rdst = 0x%x\n", rdst);
5300                   }
5301                 SYNTAX("sat     %0");
5302 #line 881 "rx-decode.opc"
5303                 ID(sat); DR (rdst);
5304
5305               }
5306             break;
5307           case 0x40:
5308               {
5309                 /** 0111 1110 0100 rdst                 rorc    %0 */
5310 #line 741 "rx-decode.opc"
5311                 int rdst AU = op[1] & 0x0f;
5312                 if (trace)
5313                   {
5314                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5315                            "/** 0111 1110 0100 rdst                     rorc    %0 */",
5316                            op[0], op[1]);
5317                     printf ("  rdst = 0x%x\n", rdst);
5318                   }
5319                 SYNTAX("rorc    %0");
5320 #line 741 "rx-decode.opc"
5321                 ID(rorc); DR(rdst); F__SZC;
5322
5323               }
5324             break;
5325           case 0x50:
5326               {
5327                 /** 0111 1110 0101 rdst                 rolc    %0 */
5328 #line 738 "rx-decode.opc"
5329                 int rdst AU = op[1] & 0x0f;
5330                 if (trace)
5331                   {
5332                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5333                            "/** 0111 1110 0101 rdst                     rolc    %0 */",
5334                            op[0], op[1]);
5335                     printf ("  rdst = 0x%x\n", rdst);
5336                   }
5337                 SYNTAX("rolc    %0");
5338 #line 738 "rx-decode.opc"
5339                 ID(rolc); DR(rdst); F__SZC;
5340
5341               }
5342             break;
5343           case 0x80:
5344           case 0x90:
5345           case 0xa0:
5346               {
5347                 /** 0111 1110 10sz rsrc         push%s  %1 */
5348 #line 374 "rx-decode.opc"
5349                 int sz AU = (op[1] >> 4) & 0x03;
5350 #line 374 "rx-decode.opc"
5351                 int rsrc AU = op[1] & 0x0f;
5352                 if (trace)
5353                   {
5354                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5355                            "/** 0111 1110 10sz rsrc             push%s  %1 */",
5356                            op[0], op[1]);
5357                     printf ("  sz = 0x%x,", sz);
5358                     printf ("  rsrc = 0x%x\n", rsrc);
5359                   }
5360                 SYNTAX("push%s  %1");
5361 #line 374 "rx-decode.opc"
5362                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
5363
5364               }
5365             break;
5366           case 0xb0:
5367               {
5368                 /** 0111 1110 1011 rdst         pop     %0 */
5369 #line 371 "rx-decode.opc"
5370                 int rdst AU = op[1] & 0x0f;
5371                 if (trace)
5372                   {
5373                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5374                            "/** 0111 1110 1011 rdst             pop     %0 */",
5375                            op[0], op[1]);
5376                     printf ("  rdst = 0x%x\n", rdst);
5377                   }
5378                 SYNTAX("pop     %0");
5379 #line 371 "rx-decode.opc"
5380                 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
5381
5382               }
5383             break;
5384           case 0xc0:
5385           case 0xd0:
5386               {
5387                 /** 0111 1110 110 crsrc                 pushc   %1 */
5388 #line 1004 "rx-decode.opc"
5389                 int crsrc AU = op[1] & 0x1f;
5390                 if (trace)
5391                   {
5392                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5393                            "/** 0111 1110 110 crsrc                     pushc   %1 */",
5394                            op[0], op[1]);
5395                     printf ("  crsrc = 0x%x\n", crsrc);
5396                   }
5397                 SYNTAX("pushc   %1");
5398 #line 1004 "rx-decode.opc"
5399                 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5400
5401               }
5402             break;
5403           case 0xe0:
5404           case 0xf0:
5405               {
5406                 /** 0111 1110 111 crdst                 popc    %0 */
5407 #line 1001 "rx-decode.opc"
5408                 int crdst AU = op[1] & 0x1f;
5409                 if (trace)
5410                   {
5411                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5412                            "/** 0111 1110 111 crdst                     popc    %0 */",
5413                            op[0], op[1]);
5414                     printf ("  crdst = 0x%x\n", crdst);
5415                   }
5416                 SYNTAX("popc    %0");
5417 #line 1001 "rx-decode.opc"
5418                 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5419
5420               }
5421             break;
5422           default: UNSUPPORTED(); break;
5423         }
5424       break;
5425     case 0x7f:
5426         GETBYTE ();
5427         switch (op[1] & 0xff)
5428         {
5429           case 0x00:
5430           case 0x01:
5431           case 0x02:
5432           case 0x03:
5433           case 0x04:
5434           case 0x05:
5435           case 0x06:
5436           case 0x07:
5437           case 0x08:
5438           case 0x09:
5439           case 0x0a:
5440           case 0x0b:
5441           case 0x0c:
5442           case 0x0d:
5443           case 0x0e:
5444           case 0x0f:
5445               {
5446                 /** 0111 1111 0000 rsrc         jmp     %0 */
5447 #line 791 "rx-decode.opc"
5448                 int rsrc AU = op[1] & 0x0f;
5449                 if (trace)
5450                   {
5451                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5452                            "/** 0111 1111 0000 rsrc             jmp     %0 */",
5453                            op[0], op[1]);
5454                     printf ("  rsrc = 0x%x\n", rsrc);
5455                   }
5456                 SYNTAX("jmp     %0");
5457 #line 791 "rx-decode.opc"
5458                 ID(branch); DR(rsrc);
5459
5460               }
5461             break;
5462           case 0x10:
5463           case 0x11:
5464           case 0x12:
5465           case 0x13:
5466           case 0x14:
5467           case 0x15:
5468           case 0x16:
5469           case 0x17:
5470           case 0x18:
5471           case 0x19:
5472           case 0x1a:
5473           case 0x1b:
5474           case 0x1c:
5475           case 0x1d:
5476           case 0x1e:
5477           case 0x1f:
5478               {
5479                 /** 0111 1111 0001 rsrc         jsr     %0 */
5480 #line 794 "rx-decode.opc"
5481                 int rsrc AU = op[1] & 0x0f;
5482                 if (trace)
5483                   {
5484                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5485                            "/** 0111 1111 0001 rsrc             jsr     %0 */",
5486                            op[0], op[1]);
5487                     printf ("  rsrc = 0x%x\n", rsrc);
5488                   }
5489                 SYNTAX("jsr     %0");
5490 #line 794 "rx-decode.opc"
5491                 ID(jsr); DR(rsrc);
5492
5493               }
5494             break;
5495           case 0x40:
5496           case 0x41:
5497           case 0x42:
5498           case 0x43:
5499           case 0x44:
5500           case 0x45:
5501           case 0x46:
5502           case 0x47:
5503           case 0x48:
5504           case 0x49:
5505           case 0x4a:
5506           case 0x4b:
5507           case 0x4c:
5508           case 0x4d:
5509           case 0x4e:
5510           case 0x4f:
5511               {
5512                 /** 0111 1111 0100 rsrc         bra.l   %0 */
5513 #line 787 "rx-decode.opc"
5514                 int rsrc AU = op[1] & 0x0f;
5515                 if (trace)
5516                   {
5517                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5518                            "/** 0111 1111 0100 rsrc             bra.l   %0 */",
5519                            op[0], op[1]);
5520                     printf ("  rsrc = 0x%x\n", rsrc);
5521                   }
5522                 SYNTAX("bra.l   %0");
5523 #line 787 "rx-decode.opc"
5524                 ID(branchrel); DR(rsrc);
5525
5526
5527               }
5528             break;
5529           case 0x50:
5530           case 0x51:
5531           case 0x52:
5532           case 0x53:
5533           case 0x54:
5534           case 0x55:
5535           case 0x56:
5536           case 0x57:
5537           case 0x58:
5538           case 0x59:
5539           case 0x5a:
5540           case 0x5b:
5541           case 0x5c:
5542           case 0x5d:
5543           case 0x5e:
5544           case 0x5f:
5545               {
5546                 /** 0111 1111 0101 rsrc         bsr.l   %0 */
5547 #line 803 "rx-decode.opc"
5548                 int rsrc AU = op[1] & 0x0f;
5549                 if (trace)
5550                   {
5551                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5552                            "/** 0111 1111 0101 rsrc             bsr.l   %0 */",
5553                            op[0], op[1]);
5554                     printf ("  rsrc = 0x%x\n", rsrc);
5555                   }
5556                 SYNTAX("bsr.l   %0");
5557 #line 803 "rx-decode.opc"
5558                 ID(jsrrel); DR(rsrc);
5559
5560               }
5561             break;
5562           case 0x80:
5563           case 0x81:
5564           case 0x82:
5565               {
5566                 /** 0111 1111 1000 00sz         suntil%s */
5567 #line 827 "rx-decode.opc"
5568                 int sz AU = op[1] & 0x03;
5569                 if (trace)
5570                   {
5571                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5572                            "/** 0111 1111 1000 00sz             suntil%s */",
5573                            op[0], op[1]);
5574                     printf ("  sz = 0x%x\n", sz);
5575                   }
5576                 SYNTAX("suntil%s");
5577 #line 827 "rx-decode.opc"
5578                 ID(suntil); BWL(sz); F___ZC;
5579
5580               }
5581             break;
5582           case 0x83:
5583               {
5584                 /** 0111 1111 1000 0011         scmpu */
5585                 if (trace)
5586                   {
5587                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5588                            "/** 0111 1111 1000 0011             scmpu */",
5589                            op[0], op[1]);
5590                   }
5591                 SYNTAX("scmpu");
5592 #line 818 "rx-decode.opc"
5593                 ID(scmpu); F___ZC;
5594
5595               }
5596             break;
5597           case 0x84:
5598           case 0x85:
5599           case 0x86:
5600               {
5601                 /** 0111 1111 1000 01sz         swhile%s */
5602 #line 830 "rx-decode.opc"
5603                 int sz AU = op[1] & 0x03;
5604                 if (trace)
5605                   {
5606                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5607                            "/** 0111 1111 1000 01sz             swhile%s */",
5608                            op[0], op[1]);
5609                     printf ("  sz = 0x%x\n", sz);
5610                   }
5611                 SYNTAX("swhile%s");
5612 #line 830 "rx-decode.opc"
5613                 ID(swhile); BWL(sz); F___ZC;
5614
5615               }
5616             break;
5617           case 0x87:
5618               {
5619                 /** 0111 1111 1000 0111         smovu */
5620                 if (trace)
5621                   {
5622                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5623                            "/** 0111 1111 1000 0111             smovu */",
5624                            op[0], op[1]);
5625                   }
5626                 SYNTAX("smovu");
5627 #line 821 "rx-decode.opc"
5628                 ID(smovu);
5629
5630               }
5631             break;
5632           case 0x88:
5633           case 0x89:
5634           case 0x8a:
5635               {
5636                 /** 0111 1111 1000 10sz         sstr%s */
5637 #line 836 "rx-decode.opc"
5638                 int sz AU = op[1] & 0x03;
5639                 if (trace)
5640                   {
5641                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5642                            "/** 0111 1111 1000 10sz             sstr%s */",
5643                            op[0], op[1]);
5644                     printf ("  sz = 0x%x\n", sz);
5645                   }
5646                 SYNTAX("sstr%s");
5647 #line 836 "rx-decode.opc"
5648                 ID(sstr); BWL(sz);
5649
5650               /*----------------------------------------------------------------------*/
5651               /* RMPA                                                                   */
5652
5653               }
5654             break;
5655           case 0x8b:
5656               {
5657                 /** 0111 1111 1000 1011         smovb */
5658                 if (trace)
5659                   {
5660                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5661                            "/** 0111 1111 1000 1011             smovb */",
5662                            op[0], op[1]);
5663                   }
5664                 SYNTAX("smovb");
5665 #line 824 "rx-decode.opc"
5666                 ID(smovb);
5667
5668               }
5669             break;
5670           case 0x8c:
5671           case 0x8d:
5672           case 0x8e:
5673               {
5674                 /** 0111 1111 1000 11sz         rmpa%s */
5675 #line 842 "rx-decode.opc"
5676                 int sz AU = op[1] & 0x03;
5677                 if (trace)
5678                   {
5679                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5680                            "/** 0111 1111 1000 11sz             rmpa%s */",
5681                            op[0], op[1]);
5682                     printf ("  sz = 0x%x\n", sz);
5683                   }
5684                 SYNTAX("rmpa%s");
5685 #line 842 "rx-decode.opc"
5686                 ID(rmpa); BWL(sz); F_OS__;
5687
5688               /*----------------------------------------------------------------------*/
5689               /* HI/LO stuff                                                            */
5690
5691               }
5692             break;
5693           case 0x8f:
5694               {
5695                 /** 0111 1111 1000 1111         smovf */
5696                 if (trace)
5697                   {
5698                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5699                            "/** 0111 1111 1000 1111             smovf */",
5700                            op[0], op[1]);
5701                   }
5702                 SYNTAX("smovf");
5703 #line 833 "rx-decode.opc"
5704                 ID(smovf);
5705
5706               }
5707             break;
5708           case 0x93:
5709               {
5710                 /** 0111 1111 1001 0011         satr */
5711                 if (trace)
5712                   {
5713                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5714                            "/** 0111 1111 1001 0011             satr */",
5715                            op[0], op[1]);
5716                   }
5717                 SYNTAX("satr");
5718 #line 884 "rx-decode.opc"
5719                 ID(satr);
5720
5721               /*----------------------------------------------------------------------*/
5722               /* FLOAT                                                          */
5723
5724               }
5725             break;
5726           case 0x94:
5727               {
5728                 /** 0111 1111 1001 0100         rtfi */
5729                 if (trace)
5730                   {
5731                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5732                            "/** 0111 1111 1001 0100             rtfi */",
5733                            op[0], op[1]);
5734                   }
5735                 SYNTAX("rtfi");
5736 #line 1019 "rx-decode.opc"
5737                 ID(rtfi);
5738
5739               }
5740             break;
5741           case 0x95:
5742               {
5743                 /** 0111 1111 1001 0101         rte */
5744                 if (trace)
5745                   {
5746                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5747                            "/** 0111 1111 1001 0101             rte */",
5748                            op[0], op[1]);
5749                   }
5750                 SYNTAX("rte");
5751 #line 1022 "rx-decode.opc"
5752                 ID(rte);
5753
5754               }
5755             break;
5756           case 0x96:
5757               {
5758                 /** 0111 1111 1001 0110         wait */
5759                 if (trace)
5760                   {
5761                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5762                            "/** 0111 1111 1001 0110             wait */",
5763                            op[0], op[1]);
5764                   }
5765                 SYNTAX("wait");
5766 #line 1034 "rx-decode.opc"
5767                 ID(wait);
5768
5769               /*----------------------------------------------------------------------*/
5770               /* SCcnd                                                          */
5771
5772               }
5773             break;
5774           case 0xa0:
5775           case 0xa1:
5776           case 0xa2:
5777           case 0xa3:
5778           case 0xa4:
5779           case 0xa5:
5780           case 0xa6:
5781           case 0xa7:
5782           case 0xa8:
5783           case 0xa9:
5784           case 0xaa:
5785           case 0xab:
5786           case 0xac:
5787           case 0xad:
5788           case 0xae:
5789           case 0xaf:
5790               {
5791                 /** 0111 1111 1010 rdst                 setpsw  %0 */
5792 #line 995 "rx-decode.opc"
5793                 int rdst AU = op[1] & 0x0f;
5794                 if (trace)
5795                   {
5796                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5797                            "/** 0111 1111 1010 rdst                     setpsw  %0 */",
5798                            op[0], op[1]);
5799                     printf ("  rdst = 0x%x\n", rdst);
5800                   }
5801                 SYNTAX("setpsw  %0");
5802 #line 995 "rx-decode.opc"
5803                 ID(setpsw); DF(rdst);
5804
5805               }
5806             break;
5807           case 0xb0:
5808           case 0xb1:
5809           case 0xb2:
5810           case 0xb3:
5811           case 0xb4:
5812           case 0xb5:
5813           case 0xb6:
5814           case 0xb7:
5815           case 0xb8:
5816           case 0xb9:
5817           case 0xba:
5818           case 0xbb:
5819           case 0xbc:
5820           case 0xbd:
5821           case 0xbe:
5822           case 0xbf:
5823               {
5824                 /** 0111 1111 1011 rdst                 clrpsw  %0 */
5825 #line 992 "rx-decode.opc"
5826                 int rdst AU = op[1] & 0x0f;
5827                 if (trace)
5828                   {
5829                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5830                            "/** 0111 1111 1011 rdst                     clrpsw  %0 */",
5831                            op[0], op[1]);
5832                     printf ("  rdst = 0x%x\n", rdst);
5833                   }
5834                 SYNTAX("clrpsw  %0");
5835 #line 992 "rx-decode.opc"
5836                 ID(clrpsw); DF(rdst);
5837
5838               }
5839             break;
5840           default: UNSUPPORTED(); break;
5841         }
5842       break;
5843     case 0x80:
5844         GETBYTE ();
5845         switch (op[1] & 0x00)
5846         {
5847           case 0x00:
5848             op_semantics_39:
5849               {
5850                 /** 10sz 0dsp a dst b src       mov%s   %1, %0 */
5851 #line 332 "rx-decode.opc"
5852                 int sz AU = (op[0] >> 4) & 0x03;
5853 #line 332 "rx-decode.opc"
5854                 int dsp AU = op[0] & 0x07;
5855 #line 332 "rx-decode.opc"
5856                 int a AU = (op[1] >> 7) & 0x01;
5857 #line 332 "rx-decode.opc"
5858                 int dst AU = (op[1] >> 4) & 0x07;
5859 #line 332 "rx-decode.opc"
5860                 int b AU = (op[1] >> 3) & 0x01;
5861 #line 332 "rx-decode.opc"
5862                 int src AU = op[1] & 0x07;
5863                 if (trace)
5864                   {
5865                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5866                            "/** 10sz 0dsp a dst b src   mov%s   %1, %0 */",
5867                            op[0], op[1]);
5868                     printf ("  sz = 0x%x,", sz);
5869                     printf ("  dsp = 0x%x,", dsp);
5870                     printf ("  a = 0x%x,", a);
5871                     printf ("  dst = 0x%x,", dst);
5872                     printf ("  b = 0x%x,", b);
5873                     printf ("  src = 0x%x\n", src);
5874                   }
5875                 SYNTAX("mov%s   %1, %0");
5876 #line 332 "rx-decode.opc"
5877                 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
5878
5879               }
5880             break;
5881         }
5882       break;
5883     case 0x81:
5884         GETBYTE ();
5885         switch (op[1] & 0x00)
5886         {
5887           case 0x00:
5888             goto op_semantics_39;
5889             break;
5890         }
5891       break;
5892     case 0x82:
5893         GETBYTE ();
5894         switch (op[1] & 0x00)
5895         {
5896           case 0x00:
5897             goto op_semantics_39;
5898             break;
5899         }
5900       break;
5901     case 0x83:
5902         GETBYTE ();
5903         switch (op[1] & 0x00)
5904         {
5905           case 0x00:
5906             goto op_semantics_39;
5907             break;
5908         }
5909       break;
5910     case 0x84:
5911         GETBYTE ();
5912         switch (op[1] & 0x00)
5913         {
5914           case 0x00:
5915             goto op_semantics_39;
5916             break;
5917         }
5918       break;
5919     case 0x85:
5920         GETBYTE ();
5921         switch (op[1] & 0x00)
5922         {
5923           case 0x00:
5924             goto op_semantics_39;
5925             break;
5926         }
5927       break;
5928     case 0x86:
5929         GETBYTE ();
5930         switch (op[1] & 0x00)
5931         {
5932           case 0x00:
5933             goto op_semantics_39;
5934             break;
5935         }
5936       break;
5937     case 0x87:
5938         GETBYTE ();
5939         switch (op[1] & 0x00)
5940         {
5941           case 0x00:
5942             goto op_semantics_39;
5943             break;
5944         }
5945       break;
5946     case 0x88:
5947         GETBYTE ();
5948         switch (op[1] & 0x00)
5949         {
5950           case 0x00:
5951             op_semantics_40:
5952               {
5953                 /** 10sz 1dsp a src b dst       mov%s   %1, %0 */
5954 #line 329 "rx-decode.opc"
5955                 int sz AU = (op[0] >> 4) & 0x03;
5956 #line 329 "rx-decode.opc"
5957                 int dsp AU = op[0] & 0x07;
5958 #line 329 "rx-decode.opc"
5959                 int a AU = (op[1] >> 7) & 0x01;
5960 #line 329 "rx-decode.opc"
5961                 int src AU = (op[1] >> 4) & 0x07;
5962 #line 329 "rx-decode.opc"
5963                 int b AU = (op[1] >> 3) & 0x01;
5964 #line 329 "rx-decode.opc"
5965                 int dst AU = op[1] & 0x07;
5966                 if (trace)
5967                   {
5968                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5969                            "/** 10sz 1dsp a src b dst   mov%s   %1, %0 */",
5970                            op[0], op[1]);
5971                     printf ("  sz = 0x%x,", sz);
5972                     printf ("  dsp = 0x%x,", dsp);
5973                     printf ("  a = 0x%x,", a);
5974                     printf ("  src = 0x%x,", src);
5975                     printf ("  b = 0x%x,", b);
5976                     printf ("  dst = 0x%x\n", dst);
5977                   }
5978                 SYNTAX("mov%s   %1, %0");
5979 #line 329 "rx-decode.opc"
5980                 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
5981
5982               }
5983             break;
5984         }
5985       break;
5986     case 0x89:
5987         GETBYTE ();
5988         switch (op[1] & 0x00)
5989         {
5990           case 0x00:
5991             goto op_semantics_40;
5992             break;
5993         }
5994       break;
5995     case 0x8a:
5996         GETBYTE ();
5997         switch (op[1] & 0x00)
5998         {
5999           case 0x00:
6000             goto op_semantics_40;
6001             break;
6002         }
6003       break;
6004     case 0x8b:
6005         GETBYTE ();
6006         switch (op[1] & 0x00)
6007         {
6008           case 0x00:
6009             goto op_semantics_40;
6010             break;
6011         }
6012       break;
6013     case 0x8c:
6014         GETBYTE ();
6015         switch (op[1] & 0x00)
6016         {
6017           case 0x00:
6018             goto op_semantics_40;
6019             break;
6020         }
6021       break;
6022     case 0x8d:
6023         GETBYTE ();
6024         switch (op[1] & 0x00)
6025         {
6026           case 0x00:
6027             goto op_semantics_40;
6028             break;
6029         }
6030       break;
6031     case 0x8e:
6032         GETBYTE ();
6033         switch (op[1] & 0x00)
6034         {
6035           case 0x00:
6036             goto op_semantics_40;
6037             break;
6038         }
6039       break;
6040     case 0x8f:
6041         GETBYTE ();
6042         switch (op[1] & 0x00)
6043         {
6044           case 0x00:
6045             goto op_semantics_40;
6046             break;
6047         }
6048       break;
6049     case 0x90:
6050         GETBYTE ();
6051         switch (op[1] & 0x00)
6052         {
6053           case 0x00:
6054             goto op_semantics_39;
6055             break;
6056         }
6057       break;
6058     case 0x91:
6059         GETBYTE ();
6060         switch (op[1] & 0x00)
6061         {
6062           case 0x00:
6063             goto op_semantics_39;
6064             break;
6065         }
6066       break;
6067     case 0x92:
6068         GETBYTE ();
6069         switch (op[1] & 0x00)
6070         {
6071           case 0x00:
6072             goto op_semantics_39;
6073             break;
6074         }
6075       break;
6076     case 0x93:
6077         GETBYTE ();
6078         switch (op[1] & 0x00)
6079         {
6080           case 0x00:
6081             goto op_semantics_39;
6082             break;
6083         }
6084       break;
6085     case 0x94:
6086         GETBYTE ();
6087         switch (op[1] & 0x00)
6088         {
6089           case 0x00:
6090             goto op_semantics_39;
6091             break;
6092         }
6093       break;
6094     case 0x95:
6095         GETBYTE ();
6096         switch (op[1] & 0x00)
6097         {
6098           case 0x00:
6099             goto op_semantics_39;
6100             break;
6101         }
6102       break;
6103     case 0x96:
6104         GETBYTE ();
6105         switch (op[1] & 0x00)
6106         {
6107           case 0x00:
6108             goto op_semantics_39;
6109             break;
6110         }
6111       break;
6112     case 0x97:
6113         GETBYTE ();
6114         switch (op[1] & 0x00)
6115         {
6116           case 0x00:
6117             goto op_semantics_39;
6118             break;
6119         }
6120       break;
6121     case 0x98:
6122         GETBYTE ();
6123         switch (op[1] & 0x00)
6124         {
6125           case 0x00:
6126             goto op_semantics_40;
6127             break;
6128         }
6129       break;
6130     case 0x99:
6131         GETBYTE ();
6132         switch (op[1] & 0x00)
6133         {
6134           case 0x00:
6135             goto op_semantics_40;
6136             break;
6137         }
6138       break;
6139     case 0x9a:
6140         GETBYTE ();
6141         switch (op[1] & 0x00)
6142         {
6143           case 0x00:
6144             goto op_semantics_40;
6145             break;
6146         }
6147       break;
6148     case 0x9b:
6149         GETBYTE ();
6150         switch (op[1] & 0x00)
6151         {
6152           case 0x00:
6153             goto op_semantics_40;
6154             break;
6155         }
6156       break;
6157     case 0x9c:
6158         GETBYTE ();
6159         switch (op[1] & 0x00)
6160         {
6161           case 0x00:
6162             goto op_semantics_40;
6163             break;
6164         }
6165       break;
6166     case 0x9d:
6167         GETBYTE ();
6168         switch (op[1] & 0x00)
6169         {
6170           case 0x00:
6171             goto op_semantics_40;
6172             break;
6173         }
6174       break;
6175     case 0x9e:
6176         GETBYTE ();
6177         switch (op[1] & 0x00)
6178         {
6179           case 0x00:
6180             goto op_semantics_40;
6181             break;
6182         }
6183       break;
6184     case 0x9f:
6185         GETBYTE ();
6186         switch (op[1] & 0x00)
6187         {
6188           case 0x00:
6189             goto op_semantics_40;
6190             break;
6191         }
6192       break;
6193     case 0xa0:
6194         GETBYTE ();
6195         switch (op[1] & 0x00)
6196         {
6197           case 0x00:
6198             goto op_semantics_39;
6199             break;
6200         }
6201       break;
6202     case 0xa1:
6203         GETBYTE ();
6204         switch (op[1] & 0x00)
6205         {
6206           case 0x00:
6207             goto op_semantics_39;
6208             break;
6209         }
6210       break;
6211     case 0xa2:
6212         GETBYTE ();
6213         switch (op[1] & 0x00)
6214         {
6215           case 0x00:
6216             goto op_semantics_39;
6217             break;
6218         }
6219       break;
6220     case 0xa3:
6221         GETBYTE ();
6222         switch (op[1] & 0x00)
6223         {
6224           case 0x00:
6225             goto op_semantics_39;
6226             break;
6227         }
6228       break;
6229     case 0xa4:
6230         GETBYTE ();
6231         switch (op[1] & 0x00)
6232         {
6233           case 0x00:
6234             goto op_semantics_39;
6235             break;
6236         }
6237       break;
6238     case 0xa5:
6239         GETBYTE ();
6240         switch (op[1] & 0x00)
6241         {
6242           case 0x00:
6243             goto op_semantics_39;
6244             break;
6245         }
6246       break;
6247     case 0xa6:
6248         GETBYTE ();
6249         switch (op[1] & 0x00)
6250         {
6251           case 0x00:
6252             goto op_semantics_39;
6253             break;
6254         }
6255       break;
6256     case 0xa7:
6257         GETBYTE ();
6258         switch (op[1] & 0x00)
6259         {
6260           case 0x00:
6261             goto op_semantics_39;
6262             break;
6263         }
6264       break;
6265     case 0xa8:
6266         GETBYTE ();
6267         switch (op[1] & 0x00)
6268         {
6269           case 0x00:
6270             goto op_semantics_40;
6271             break;
6272         }
6273       break;
6274     case 0xa9:
6275         GETBYTE ();
6276         switch (op[1] & 0x00)
6277         {
6278           case 0x00:
6279             goto op_semantics_40;
6280             break;
6281         }
6282       break;
6283     case 0xaa:
6284         GETBYTE ();
6285         switch (op[1] & 0x00)
6286         {
6287           case 0x00:
6288             goto op_semantics_40;
6289             break;
6290         }
6291       break;
6292     case 0xab:
6293         GETBYTE ();
6294         switch (op[1] & 0x00)
6295         {
6296           case 0x00:
6297             goto op_semantics_40;
6298             break;
6299         }
6300       break;
6301     case 0xac:
6302         GETBYTE ();
6303         switch (op[1] & 0x00)
6304         {
6305           case 0x00:
6306             goto op_semantics_40;
6307             break;
6308         }
6309       break;
6310     case 0xad:
6311         GETBYTE ();
6312         switch (op[1] & 0x00)
6313         {
6314           case 0x00:
6315             goto op_semantics_40;
6316             break;
6317         }
6318       break;
6319     case 0xae:
6320         GETBYTE ();
6321         switch (op[1] & 0x00)
6322         {
6323           case 0x00:
6324             goto op_semantics_40;
6325             break;
6326         }
6327       break;
6328     case 0xaf:
6329         GETBYTE ();
6330         switch (op[1] & 0x00)
6331         {
6332           case 0x00:
6333             goto op_semantics_40;
6334             break;
6335         }
6336       break;
6337     case 0xb0:
6338         GETBYTE ();
6339         switch (op[1] & 0x00)
6340         {
6341           case 0x00:
6342             op_semantics_41:
6343               {
6344                 /** 1011 w dsp a src b dst      movu%s  %1, %0 */
6345 #line 352 "rx-decode.opc"
6346                 int w AU = (op[0] >> 3) & 0x01;
6347 #line 352 "rx-decode.opc"
6348                 int dsp AU = op[0] & 0x07;
6349 #line 352 "rx-decode.opc"
6350                 int a AU = (op[1] >> 7) & 0x01;
6351 #line 352 "rx-decode.opc"
6352                 int src AU = (op[1] >> 4) & 0x07;
6353 #line 352 "rx-decode.opc"
6354                 int b AU = (op[1] >> 3) & 0x01;
6355 #line 352 "rx-decode.opc"
6356                 int dst AU = op[1] & 0x07;
6357                 if (trace)
6358                   {
6359                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6360                            "/** 1011 w dsp a src b dst  movu%s  %1, %0 */",
6361                            op[0], op[1]);
6362                     printf ("  w = 0x%x,", w);
6363                     printf ("  dsp = 0x%x,", dsp);
6364                     printf ("  a = 0x%x,", a);
6365                     printf ("  src = 0x%x,", src);
6366                     printf ("  b = 0x%x,", b);
6367                     printf ("  dst = 0x%x\n", dst);
6368                   }
6369                 SYNTAX("movu%s  %1, %0");
6370 #line 352 "rx-decode.opc"
6371                 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
6372
6373               }
6374             break;
6375         }
6376       break;
6377     case 0xb1:
6378         GETBYTE ();
6379         switch (op[1] & 0x00)
6380         {
6381           case 0x00:
6382             goto op_semantics_41;
6383             break;
6384         }
6385       break;
6386     case 0xb2:
6387         GETBYTE ();
6388         switch (op[1] & 0x00)
6389         {
6390           case 0x00:
6391             goto op_semantics_41;
6392             break;
6393         }
6394       break;
6395     case 0xb3:
6396         GETBYTE ();
6397         switch (op[1] & 0x00)
6398         {
6399           case 0x00:
6400             goto op_semantics_41;
6401             break;
6402         }
6403       break;
6404     case 0xb4:
6405         GETBYTE ();
6406         switch (op[1] & 0x00)
6407         {
6408           case 0x00:
6409             goto op_semantics_41;
6410             break;
6411         }
6412       break;
6413     case 0xb5:
6414         GETBYTE ();
6415         switch (op[1] & 0x00)
6416         {
6417           case 0x00:
6418             goto op_semantics_41;
6419             break;
6420         }
6421       break;
6422     case 0xb6:
6423         GETBYTE ();
6424         switch (op[1] & 0x00)
6425         {
6426           case 0x00:
6427             goto op_semantics_41;
6428             break;
6429         }
6430       break;
6431     case 0xb7:
6432         GETBYTE ();
6433         switch (op[1] & 0x00)
6434         {
6435           case 0x00:
6436             goto op_semantics_41;
6437             break;
6438         }
6439       break;
6440     case 0xb8:
6441         GETBYTE ();
6442         switch (op[1] & 0x00)
6443         {
6444           case 0x00:
6445             goto op_semantics_41;
6446             break;
6447         }
6448       break;
6449     case 0xb9:
6450         GETBYTE ();
6451         switch (op[1] & 0x00)
6452         {
6453           case 0x00:
6454             goto op_semantics_41;
6455             break;
6456         }
6457       break;
6458     case 0xba:
6459         GETBYTE ();
6460         switch (op[1] & 0x00)
6461         {
6462           case 0x00:
6463             goto op_semantics_41;
6464             break;
6465         }
6466       break;
6467     case 0xbb:
6468         GETBYTE ();
6469         switch (op[1] & 0x00)
6470         {
6471           case 0x00:
6472             goto op_semantics_41;
6473             break;
6474         }
6475       break;
6476     case 0xbc:
6477         GETBYTE ();
6478         switch (op[1] & 0x00)
6479         {
6480           case 0x00:
6481             goto op_semantics_41;
6482             break;
6483         }
6484       break;
6485     case 0xbd:
6486         GETBYTE ();
6487         switch (op[1] & 0x00)
6488         {
6489           case 0x00:
6490             goto op_semantics_41;
6491             break;
6492         }
6493       break;
6494     case 0xbe:
6495         GETBYTE ();
6496         switch (op[1] & 0x00)
6497         {
6498           case 0x00:
6499             goto op_semantics_41;
6500             break;
6501         }
6502       break;
6503     case 0xbf:
6504         GETBYTE ();
6505         switch (op[1] & 0x00)
6506         {
6507           case 0x00:
6508             goto op_semantics_41;
6509             break;
6510         }
6511       break;
6512     case 0xc0:
6513         GETBYTE ();
6514         switch (op[1] & 0x00)
6515         {
6516           case 0x00:
6517             op_semantics_42:
6518               {
6519                 /** 11sz sd ss rsrc rdst        mov%s   %1, %0 */
6520 #line 310 "rx-decode.opc"
6521                 int sz AU = (op[0] >> 4) & 0x03;
6522 #line 310 "rx-decode.opc"
6523                 int sd AU = (op[0] >> 2) & 0x03;
6524 #line 310 "rx-decode.opc"
6525                 int ss AU = op[0] & 0x03;
6526 #line 310 "rx-decode.opc"
6527                 int rsrc AU = (op[1] >> 4) & 0x0f;
6528 #line 310 "rx-decode.opc"
6529                 int rdst AU = op[1] & 0x0f;
6530                 if (trace)
6531                   {
6532                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6533                            "/** 11sz sd ss rsrc rdst    mov%s   %1, %0 */",
6534                            op[0], op[1]);
6535                     printf ("  sz = 0x%x,", sz);
6536                     printf ("  sd = 0x%x,", sd);
6537                     printf ("  ss = 0x%x,", ss);
6538                     printf ("  rsrc = 0x%x,", rsrc);
6539                     printf ("  rdst = 0x%x\n", rdst);
6540                   }
6541                 SYNTAX("mov%s   %1, %0");
6542 #line 310 "rx-decode.opc"
6543                 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
6544                   {
6545                     ID(nop2);
6546                     SYNTAX ("nop\t; mov.l\tr0, r0");
6547                   }
6548                 else
6549                   {
6550                     ID(mov); sBWL(sz); F_____;
6551                     if ((ss == 3) && (sd != 3))
6552                 {
6553                   SD(ss, rdst, sz); DD(sd, rsrc, sz);
6554                 }
6555                     else
6556                 {
6557                   SD(ss, rsrc, sz); DD(sd, rdst, sz);
6558                 }
6559                   }
6560
6561               }
6562             break;
6563         }
6564       break;
6565     case 0xc1:
6566         GETBYTE ();
6567         switch (op[1] & 0x00)
6568         {
6569           case 0x00:
6570             goto op_semantics_42;
6571             break;
6572         }
6573       break;
6574     case 0xc2:
6575         GETBYTE ();
6576         switch (op[1] & 0x00)
6577         {
6578           case 0x00:
6579             goto op_semantics_42;
6580             break;
6581         }
6582       break;
6583     case 0xc3:
6584         GETBYTE ();
6585         switch (op[1] & 0x00)
6586         {
6587           case 0x00:
6588             goto op_semantics_42;
6589             break;
6590         }
6591       break;
6592     case 0xc4:
6593         GETBYTE ();
6594         switch (op[1] & 0x00)
6595         {
6596           case 0x00:
6597             goto op_semantics_42;
6598             break;
6599         }
6600       break;
6601     case 0xc5:
6602         GETBYTE ();
6603         switch (op[1] & 0x00)
6604         {
6605           case 0x00:
6606             goto op_semantics_42;
6607             break;
6608         }
6609       break;
6610     case 0xc6:
6611         GETBYTE ();
6612         switch (op[1] & 0x00)
6613         {
6614           case 0x00:
6615             goto op_semantics_42;
6616             break;
6617         }
6618       break;
6619     case 0xc7:
6620         GETBYTE ();
6621         switch (op[1] & 0x00)
6622         {
6623           case 0x00:
6624             goto op_semantics_42;
6625             break;
6626         }
6627       break;
6628     case 0xc8:
6629         GETBYTE ();
6630         switch (op[1] & 0x00)
6631         {
6632           case 0x00:
6633             goto op_semantics_42;
6634             break;
6635         }
6636       break;
6637     case 0xc9:
6638         GETBYTE ();
6639         switch (op[1] & 0x00)
6640         {
6641           case 0x00:
6642             goto op_semantics_42;
6643             break;
6644         }
6645       break;
6646     case 0xca:
6647         GETBYTE ();
6648         switch (op[1] & 0x00)
6649         {
6650           case 0x00:
6651             goto op_semantics_42;
6652             break;
6653         }
6654       break;
6655     case 0xcb:
6656         GETBYTE ();
6657         switch (op[1] & 0x00)
6658         {
6659           case 0x00:
6660             goto op_semantics_42;
6661             break;
6662         }
6663       break;
6664     case 0xcc:
6665         GETBYTE ();
6666         switch (op[1] & 0x00)
6667         {
6668           case 0x00:
6669             goto op_semantics_42;
6670             break;
6671         }
6672       break;
6673     case 0xcd:
6674         GETBYTE ();
6675         switch (op[1] & 0x00)
6676         {
6677           case 0x00:
6678             goto op_semantics_42;
6679             break;
6680         }
6681       break;
6682     case 0xce:
6683         GETBYTE ();
6684         switch (op[1] & 0x00)
6685         {
6686           case 0x00:
6687             goto op_semantics_42;
6688             break;
6689         }
6690       break;
6691     case 0xcf:
6692         GETBYTE ();
6693         switch (op[1] & 0x00)
6694         {
6695           case 0x00:
6696             goto op_semantics_42;
6697             break;
6698         }
6699       break;
6700     case 0xd0:
6701         GETBYTE ();
6702         switch (op[1] & 0x00)
6703         {
6704           case 0x00:
6705             goto op_semantics_42;
6706             break;
6707         }
6708       break;
6709     case 0xd1:
6710         GETBYTE ();
6711         switch (op[1] & 0x00)
6712         {
6713           case 0x00:
6714             goto op_semantics_42;
6715             break;
6716         }
6717       break;
6718     case 0xd2:
6719         GETBYTE ();
6720         switch (op[1] & 0x00)
6721         {
6722           case 0x00:
6723             goto op_semantics_42;
6724             break;
6725         }
6726       break;
6727     case 0xd3:
6728         GETBYTE ();
6729         switch (op[1] & 0x00)
6730         {
6731           case 0x00:
6732             goto op_semantics_42;
6733             break;
6734         }
6735       break;
6736     case 0xd4:
6737         GETBYTE ();
6738         switch (op[1] & 0x00)
6739         {
6740           case 0x00:
6741             goto op_semantics_42;
6742             break;
6743         }
6744       break;
6745     case 0xd5:
6746         GETBYTE ();
6747         switch (op[1] & 0x00)
6748         {
6749           case 0x00:
6750             goto op_semantics_42;
6751             break;
6752         }
6753       break;
6754     case 0xd6:
6755         GETBYTE ();
6756         switch (op[1] & 0x00)
6757         {
6758           case 0x00:
6759             goto op_semantics_42;
6760             break;
6761         }
6762       break;
6763     case 0xd7:
6764         GETBYTE ();
6765         switch (op[1] & 0x00)
6766         {
6767           case 0x00:
6768             goto op_semantics_42;
6769             break;
6770         }
6771       break;
6772     case 0xd8:
6773         GETBYTE ();
6774         switch (op[1] & 0x00)
6775         {
6776           case 0x00:
6777             goto op_semantics_42;
6778             break;
6779         }
6780       break;
6781     case 0xd9:
6782         GETBYTE ();
6783         switch (op[1] & 0x00)
6784         {
6785           case 0x00:
6786             goto op_semantics_42;
6787             break;
6788         }
6789       break;
6790     case 0xda:
6791         GETBYTE ();
6792         switch (op[1] & 0x00)
6793         {
6794           case 0x00:
6795             goto op_semantics_42;
6796             break;
6797         }
6798       break;
6799     case 0xdb:
6800         GETBYTE ();
6801         switch (op[1] & 0x00)
6802         {
6803           case 0x00:
6804             goto op_semantics_42;
6805             break;
6806         }
6807       break;
6808     case 0xdc:
6809         GETBYTE ();
6810         switch (op[1] & 0x00)
6811         {
6812           case 0x00:
6813             goto op_semantics_42;
6814             break;
6815         }
6816       break;
6817     case 0xdd:
6818         GETBYTE ();
6819         switch (op[1] & 0x00)
6820         {
6821           case 0x00:
6822             goto op_semantics_42;
6823             break;
6824         }
6825       break;
6826     case 0xde:
6827         GETBYTE ();
6828         switch (op[1] & 0x00)
6829         {
6830           case 0x00:
6831             goto op_semantics_42;
6832             break;
6833         }
6834       break;
6835     case 0xdf:
6836         GETBYTE ();
6837         switch (op[1] & 0x00)
6838         {
6839           case 0x00:
6840             goto op_semantics_42;
6841             break;
6842         }
6843       break;
6844     case 0xe0:
6845         GETBYTE ();
6846         switch (op[1] & 0x00)
6847         {
6848           case 0x00:
6849             goto op_semantics_42;
6850             break;
6851         }
6852       break;
6853     case 0xe1:
6854         GETBYTE ();
6855         switch (op[1] & 0x00)
6856         {
6857           case 0x00:
6858             goto op_semantics_42;
6859             break;
6860         }
6861       break;
6862     case 0xe2:
6863         GETBYTE ();
6864         switch (op[1] & 0x00)
6865         {
6866           case 0x00:
6867             goto op_semantics_42;
6868             break;
6869         }
6870       break;
6871     case 0xe3:
6872         GETBYTE ();
6873         switch (op[1] & 0x00)
6874         {
6875           case 0x00:
6876             goto op_semantics_42;
6877             break;
6878         }
6879       break;
6880     case 0xe4:
6881         GETBYTE ();
6882         switch (op[1] & 0x00)
6883         {
6884           case 0x00:
6885             goto op_semantics_42;
6886             break;
6887         }
6888       break;
6889     case 0xe5:
6890         GETBYTE ();
6891         switch (op[1] & 0x00)
6892         {
6893           case 0x00:
6894             goto op_semantics_42;
6895             break;
6896         }
6897       break;
6898     case 0xe6:
6899         GETBYTE ();
6900         switch (op[1] & 0x00)
6901         {
6902           case 0x00:
6903             goto op_semantics_42;
6904             break;
6905         }
6906       break;
6907     case 0xe7:
6908         GETBYTE ();
6909         switch (op[1] & 0x00)
6910         {
6911           case 0x00:
6912             goto op_semantics_42;
6913             break;
6914         }
6915       break;
6916     case 0xe8:
6917         GETBYTE ();
6918         switch (op[1] & 0x00)
6919         {
6920           case 0x00:
6921             goto op_semantics_42;
6922             break;
6923         }
6924       break;
6925     case 0xe9:
6926         GETBYTE ();
6927         switch (op[1] & 0x00)
6928         {
6929           case 0x00:
6930             goto op_semantics_42;
6931             break;
6932         }
6933       break;
6934     case 0xea:
6935         GETBYTE ();
6936         switch (op[1] & 0x00)
6937         {
6938           case 0x00:
6939             goto op_semantics_42;
6940             break;
6941         }
6942       break;
6943     case 0xeb:
6944         GETBYTE ();
6945         switch (op[1] & 0x00)
6946         {
6947           case 0x00:
6948             goto op_semantics_42;
6949             break;
6950         }
6951       break;
6952     case 0xec:
6953         GETBYTE ();
6954         switch (op[1] & 0x00)
6955         {
6956           case 0x00:
6957             goto op_semantics_42;
6958             break;
6959         }
6960       break;
6961     case 0xed:
6962         GETBYTE ();
6963         switch (op[1] & 0x00)
6964         {
6965           case 0x00:
6966             goto op_semantics_42;
6967             break;
6968         }
6969       break;
6970     case 0xee:
6971         GETBYTE ();
6972         switch (op[1] & 0x00)
6973         {
6974           case 0x00:
6975             goto op_semantics_42;
6976             break;
6977         }
6978       break;
6979     case 0xef:
6980         GETBYTE ();
6981         switch (op[1] & 0x00)
6982         {
6983           case 0x00:
6984             goto op_semantics_42;
6985             break;
6986         }
6987       break;
6988     case 0xf0:
6989         GETBYTE ();
6990         switch (op[1] & 0x08)
6991         {
6992           case 0x00:
6993             op_semantics_43:
6994               {
6995                 /** 1111 00sd rdst 0bit                 bset    #%1, %0%S0 */
6996 #line 935 "rx-decode.opc"
6997                 int sd AU = op[0] & 0x03;
6998 #line 935 "rx-decode.opc"
6999                 int rdst AU = (op[1] >> 4) & 0x0f;
7000 #line 935 "rx-decode.opc"
7001                 int bit AU = op[1] & 0x07;
7002                 if (trace)
7003                   {
7004                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7005                            "/** 1111 00sd rdst 0bit                     bset    #%1, %0%S0 */",
7006                            op[0], op[1]);
7007                     printf ("  sd = 0x%x,", sd);
7008                     printf ("  rdst = 0x%x,", rdst);
7009                     printf ("  bit = 0x%x\n", bit);
7010                   }
7011                 SYNTAX("bset    #%1, %0%S0");
7012 #line 935 "rx-decode.opc"
7013                 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
7014
7015               }
7016             break;
7017           case 0x08:
7018             op_semantics_44:
7019               {
7020                 /** 1111 00sd rdst 1bit                 bclr    #%1, %0%S0 */
7021 #line 947 "rx-decode.opc"
7022                 int sd AU = op[0] & 0x03;
7023 #line 947 "rx-decode.opc"
7024                 int rdst AU = (op[1] >> 4) & 0x0f;
7025 #line 947 "rx-decode.opc"
7026                 int bit AU = op[1] & 0x07;
7027                 if (trace)
7028                   {
7029                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7030                            "/** 1111 00sd rdst 1bit                     bclr    #%1, %0%S0 */",
7031                            op[0], op[1]);
7032                     printf ("  sd = 0x%x,", sd);
7033                     printf ("  rdst = 0x%x,", rdst);
7034                     printf ("  bit = 0x%x\n", bit);
7035                   }
7036                 SYNTAX("bclr    #%1, %0%S0");
7037 #line 947 "rx-decode.opc"
7038                 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
7039
7040               }
7041             break;
7042         }
7043       break;
7044     case 0xf1:
7045         GETBYTE ();
7046         switch (op[1] & 0x08)
7047         {
7048           case 0x00:
7049             goto op_semantics_43;
7050             break;
7051           case 0x08:
7052             goto op_semantics_44;
7053             break;
7054         }
7055       break;
7056     case 0xf2:
7057         GETBYTE ();
7058         switch (op[1] & 0x08)
7059         {
7060           case 0x00:
7061             goto op_semantics_43;
7062             break;
7063           case 0x08:
7064             goto op_semantics_44;
7065             break;
7066         }
7067       break;
7068     case 0xf3:
7069         GETBYTE ();
7070         switch (op[1] & 0x08)
7071         {
7072           case 0x00:
7073             goto op_semantics_43;
7074             break;
7075           case 0x08:
7076             goto op_semantics_44;
7077             break;
7078         }
7079       break;
7080     case 0xf4:
7081         GETBYTE ();
7082         switch (op[1] & 0x0c)
7083         {
7084           case 0x00:
7085           case 0x04:
7086             op_semantics_45:
7087               {
7088                 /** 1111 01sd rdst 0bit                 btst    #%2, %1%S1 */
7089 #line 959 "rx-decode.opc"
7090                 int sd AU = op[0] & 0x03;
7091 #line 959 "rx-decode.opc"
7092                 int rdst AU = (op[1] >> 4) & 0x0f;
7093 #line 959 "rx-decode.opc"
7094                 int bit AU = op[1] & 0x07;
7095                 if (trace)
7096                   {
7097                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7098                            "/** 1111 01sd rdst 0bit                     btst    #%2, %1%S1 */",
7099                            op[0], op[1]);
7100                     printf ("  sd = 0x%x,", sd);
7101                     printf ("  rdst = 0x%x,", rdst);
7102                     printf ("  bit = 0x%x\n", bit);
7103                   }
7104                 SYNTAX("btst    #%2, %1%S1");
7105 #line 959 "rx-decode.opc"
7106                 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
7107
7108               }
7109             break;
7110           case 0x08:
7111             op_semantics_46:
7112               {
7113                 /** 1111 01ss rsrc 10sz         push%s  %1 */
7114 #line 377 "rx-decode.opc"
7115                 int ss AU = op[0] & 0x03;
7116 #line 377 "rx-decode.opc"
7117                 int rsrc AU = (op[1] >> 4) & 0x0f;
7118 #line 377 "rx-decode.opc"
7119                 int sz AU = op[1] & 0x03;
7120                 if (trace)
7121                   {
7122                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7123                            "/** 1111 01ss rsrc 10sz             push%s  %1 */",
7124                            op[0], op[1]);
7125                     printf ("  ss = 0x%x,", ss);
7126                     printf ("  rsrc = 0x%x,", rsrc);
7127                     printf ("  sz = 0x%x\n", sz);
7128                   }
7129                 SYNTAX("push%s  %1");
7130 #line 377 "rx-decode.opc"
7131                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
7132
7133               /*----------------------------------------------------------------------*/
7134               /* XCHG                                                                   */
7135
7136               }
7137             break;
7138           default: UNSUPPORTED(); break;
7139         }
7140       break;
7141     case 0xf5:
7142         GETBYTE ();
7143         switch (op[1] & 0x0c)
7144         {
7145           case 0x00:
7146           case 0x04:
7147             goto op_semantics_45;
7148             break;
7149           case 0x08:
7150             goto op_semantics_46;
7151             break;
7152           default: UNSUPPORTED(); break;
7153         }
7154       break;
7155     case 0xf6:
7156         GETBYTE ();
7157         switch (op[1] & 0x0c)
7158         {
7159           case 0x00:
7160           case 0x04:
7161             goto op_semantics_45;
7162             break;
7163           case 0x08:
7164             goto op_semantics_46;
7165             break;
7166           default: UNSUPPORTED(); break;
7167         }
7168       break;
7169     case 0xf7:
7170         GETBYTE ();
7171         switch (op[1] & 0x0c)
7172         {
7173           case 0x00:
7174           case 0x04:
7175             goto op_semantics_45;
7176             break;
7177           case 0x08:
7178             goto op_semantics_46;
7179             break;
7180           default: UNSUPPORTED(); break;
7181         }
7182       break;
7183     case 0xf8:
7184         GETBYTE ();
7185         switch (op[1] & 0x00)
7186         {
7187           case 0x00:
7188             op_semantics_47:
7189               {
7190                 /** 1111 10sd rdst im sz        mov%s   #%1, %0 */
7191 #line 288 "rx-decode.opc"
7192                 int sd AU = op[0] & 0x03;
7193 #line 288 "rx-decode.opc"
7194                 int rdst AU = (op[1] >> 4) & 0x0f;
7195 #line 288 "rx-decode.opc"
7196                 int im AU = (op[1] >> 2) & 0x03;
7197 #line 288 "rx-decode.opc"
7198                 int sz AU = op[1] & 0x03;
7199                 if (trace)
7200                   {
7201                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7202                            "/** 1111 10sd rdst im sz    mov%s   #%1, %0 */",
7203                            op[0], op[1]);
7204                     printf ("  sd = 0x%x,", sd);
7205                     printf ("  rdst = 0x%x,", rdst);
7206                     printf ("  im = 0x%x,", im);
7207                     printf ("  sz = 0x%x\n", sz);
7208                   }
7209                 SYNTAX("mov%s   #%1, %0");
7210 #line 288 "rx-decode.opc"
7211                 ID(mov); DD(sd, rdst, sz);
7212                 if ((im == 1 && sz == 0)
7213                     || (im == 2 && sz == 1)
7214                     || (im == 0 && sz == 2))
7215                   {
7216                     BWL (sz);
7217                     SC(IMM(im));
7218                   }
7219                 else
7220                   {
7221                     sBWL (sz);
7222                     SC(IMMex(im));
7223                   }
7224                  F_____;
7225
7226               }
7227             break;
7228         }
7229       break;
7230     case 0xf9:
7231         GETBYTE ();
7232         switch (op[1] & 0x00)
7233         {
7234           case 0x00:
7235             goto op_semantics_47;
7236             break;
7237         }
7238       break;
7239     case 0xfa:
7240         GETBYTE ();
7241         switch (op[1] & 0x00)
7242         {
7243           case 0x00:
7244             goto op_semantics_47;
7245             break;
7246         }
7247       break;
7248     case 0xfb:
7249         GETBYTE ();
7250         switch (op[1] & 0x00)
7251         {
7252           case 0x00:
7253             goto op_semantics_47;
7254             break;
7255         }
7256       break;
7257     case 0xfc:
7258         GETBYTE ();
7259         switch (op[1] & 0xff)
7260         {
7261           case 0x03:
7262               GETBYTE ();
7263               switch (op[2] & 0x00)
7264               {
7265                 case 0x00:
7266                     {
7267                       /** 1111 1100 0000 0011 rsrc rdst sbb     %1, %0 */
7268 #line 551 "rx-decode.opc"
7269                       int rsrc AU = (op[2] >> 4) & 0x0f;
7270 #line 551 "rx-decode.opc"
7271                       int rdst AU = op[2] & 0x0f;
7272                       if (trace)
7273                         {
7274                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7275                                  "/** 1111 1100 0000 0011 rsrc rdst     sbb     %1, %0 */",
7276                                  op[0], op[1], op[2]);
7277                           printf ("  rsrc = 0x%x,", rsrc);
7278                           printf ("  rdst = 0x%x\n", rdst);
7279                         }
7280                       SYNTAX("sbb       %1, %0");
7281 #line 551 "rx-decode.opc"
7282                       ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
7283
7284                       /* FIXME: only supports .L */
7285                     }
7286                   break;
7287               }
7288             break;
7289           case 0x07:
7290               GETBYTE ();
7291               switch (op[2] & 0x00)
7292               {
7293                 case 0x00:
7294                     {
7295                       /** 1111 1100 0000 0111 rsrc rdst neg     %2, %0 */
7296 #line 482 "rx-decode.opc"
7297                       int rsrc AU = (op[2] >> 4) & 0x0f;
7298 #line 482 "rx-decode.opc"
7299                       int rdst AU = op[2] & 0x0f;
7300                       if (trace)
7301                         {
7302                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7303                                  "/** 1111 1100 0000 0111 rsrc rdst     neg     %2, %0 */",
7304                                  op[0], op[1], op[2]);
7305                           printf ("  rsrc = 0x%x,", rsrc);
7306                           printf ("  rdst = 0x%x\n", rdst);
7307                         }
7308                       SYNTAX("neg       %2, %0");
7309 #line 482 "rx-decode.opc"
7310                       ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
7311
7312                     /*----------------------------------------------------------------------*/
7313                     /* ADC                                                                      */
7314
7315                     }
7316                   break;
7317               }
7318             break;
7319           case 0x0b:
7320               GETBYTE ();
7321               switch (op[2] & 0x00)
7322               {
7323                 case 0x00:
7324                     {
7325                       /** 1111 1100 0000 1011 rsrc rdst adc     %1, %0 */
7326 #line 491 "rx-decode.opc"
7327                       int rsrc AU = (op[2] >> 4) & 0x0f;
7328 #line 491 "rx-decode.opc"
7329                       int rdst AU = op[2] & 0x0f;
7330                       if (trace)
7331                         {
7332                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7333                                  "/** 1111 1100 0000 1011 rsrc rdst     adc     %1, %0 */",
7334                                  op[0], op[1], op[2]);
7335                           printf ("  rsrc = 0x%x,", rsrc);
7336                           printf ("  rdst = 0x%x\n", rdst);
7337                         }
7338                       SYNTAX("adc       %1, %0");
7339 #line 491 "rx-decode.opc"
7340                       ID(adc); SR(rsrc); DR(rdst); F_OSZC;
7341
7342                     }
7343                   break;
7344               }
7345             break;
7346           case 0x0f:
7347               GETBYTE ();
7348               switch (op[2] & 0x00)
7349               {
7350                 case 0x00:
7351                     {
7352                       /** 1111 1100 0000 1111 rsrc rdst abs     %1, %0 */
7353 #line 564 "rx-decode.opc"
7354                       int rsrc AU = (op[2] >> 4) & 0x0f;
7355 #line 564 "rx-decode.opc"
7356                       int rdst AU = op[2] & 0x0f;
7357                       if (trace)
7358                         {
7359                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7360                                  "/** 1111 1100 0000 1111 rsrc rdst     abs     %1, %0 */",
7361                                  op[0], op[1], op[2]);
7362                           printf ("  rsrc = 0x%x,", rsrc);
7363                           printf ("  rdst = 0x%x\n", rdst);
7364                         }
7365                       SYNTAX("abs       %1, %0");
7366 #line 564 "rx-decode.opc"
7367                       ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
7368
7369                     /*----------------------------------------------------------------------*/
7370                     /* MAX                                                                      */
7371
7372                     }
7373                   break;
7374               }
7375             break;
7376           case 0x10:
7377               GETBYTE ();
7378               switch (op[2] & 0x00)
7379               {
7380                 case 0x00:
7381                   op_semantics_48:
7382                     {
7383                       /** 1111 1100 0001 00ss rsrc rdst max     %1%S1, %0 */
7384 #line 583 "rx-decode.opc"
7385                       int ss AU = op[1] & 0x03;
7386 #line 583 "rx-decode.opc"
7387                       int rsrc AU = (op[2] >> 4) & 0x0f;
7388 #line 583 "rx-decode.opc"
7389                       int rdst AU = op[2] & 0x0f;
7390                       if (trace)
7391                         {
7392                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7393                                  "/** 1111 1100 0001 00ss rsrc rdst     max     %1%S1, %0 */",
7394                                  op[0], op[1], op[2]);
7395                           printf ("  ss = 0x%x,", ss);
7396                           printf ("  rsrc = 0x%x,", rsrc);
7397                           printf ("  rdst = 0x%x\n", rdst);
7398                         }
7399                       SYNTAX("max       %1%S1, %0");
7400 #line 583 "rx-decode.opc"
7401                       if (ss == 3 && rsrc == 0 && rdst == 0)
7402                         {
7403                           ID(nop3);
7404                           SYNTAX("nop\t; max\tr0, r0");
7405                         }
7406                       else
7407                         {
7408                           ID(max); SP(ss, rsrc); DR(rdst);
7409                         }
7410
7411                     }
7412                   break;
7413               }
7414             break;
7415           case 0x11:
7416               GETBYTE ();
7417               switch (op[2] & 0x00)
7418               {
7419                 case 0x00:
7420                   goto op_semantics_48;
7421                   break;
7422               }
7423             break;
7424           case 0x12:
7425               GETBYTE ();
7426               switch (op[2] & 0x00)
7427               {
7428                 case 0x00:
7429                   goto op_semantics_48;
7430                   break;
7431               }
7432             break;
7433           case 0x13:
7434               GETBYTE ();
7435               switch (op[2] & 0x00)
7436               {
7437                 case 0x00:
7438                   goto op_semantics_48;
7439                   break;
7440               }
7441             break;
7442           case 0x14:
7443               GETBYTE ();
7444               switch (op[2] & 0x00)
7445               {
7446                 case 0x00:
7447                   op_semantics_49:
7448                     {
7449                       /** 1111 1100 0001 01ss rsrc rdst min     %1%S1, %0 */
7450 #line 603 "rx-decode.opc"
7451                       int ss AU = op[1] & 0x03;
7452 #line 603 "rx-decode.opc"
7453                       int rsrc AU = (op[2] >> 4) & 0x0f;
7454 #line 603 "rx-decode.opc"
7455                       int rdst AU = op[2] & 0x0f;
7456                       if (trace)
7457                         {
7458                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7459                                  "/** 1111 1100 0001 01ss rsrc rdst     min     %1%S1, %0 */",
7460                                  op[0], op[1], op[2]);
7461                           printf ("  ss = 0x%x,", ss);
7462                           printf ("  rsrc = 0x%x,", rsrc);
7463                           printf ("  rdst = 0x%x\n", rdst);
7464                         }
7465                       SYNTAX("min       %1%S1, %0");
7466 #line 603 "rx-decode.opc"
7467                       ID(min); SP(ss, rsrc); DR(rdst);
7468
7469                     }
7470                   break;
7471               }
7472             break;
7473           case 0x15:
7474               GETBYTE ();
7475               switch (op[2] & 0x00)
7476               {
7477                 case 0x00:
7478                   goto op_semantics_49;
7479                   break;
7480               }
7481             break;
7482           case 0x16:
7483               GETBYTE ();
7484               switch (op[2] & 0x00)
7485               {
7486                 case 0x00:
7487                   goto op_semantics_49;
7488                   break;
7489               }
7490             break;
7491           case 0x17:
7492               GETBYTE ();
7493               switch (op[2] & 0x00)
7494               {
7495                 case 0x00:
7496                   goto op_semantics_49;
7497                   break;
7498               }
7499             break;
7500           case 0x18:
7501               GETBYTE ();
7502               switch (op[2] & 0x00)
7503               {
7504                 case 0x00:
7505                   op_semantics_50:
7506                     {
7507                       /** 1111 1100 0001 10ss rsrc rdst emul    %1%S1, %0 */
7508 #line 661 "rx-decode.opc"
7509                       int ss AU = op[1] & 0x03;
7510 #line 661 "rx-decode.opc"
7511                       int rsrc AU = (op[2] >> 4) & 0x0f;
7512 #line 661 "rx-decode.opc"
7513                       int rdst AU = op[2] & 0x0f;
7514                       if (trace)
7515                         {
7516                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7517                                  "/** 1111 1100 0001 10ss rsrc rdst     emul    %1%S1, %0 */",
7518                                  op[0], op[1], op[2]);
7519                           printf ("  ss = 0x%x,", ss);
7520                           printf ("  rsrc = 0x%x,", rsrc);
7521                           printf ("  rdst = 0x%x\n", rdst);
7522                         }
7523                       SYNTAX("emul      %1%S1, %0");
7524 #line 661 "rx-decode.opc"
7525                       ID(emul); SP(ss, rsrc); DR(rdst);
7526
7527                     }
7528                   break;
7529               }
7530             break;
7531           case 0x19:
7532               GETBYTE ();
7533               switch (op[2] & 0x00)
7534               {
7535                 case 0x00:
7536                   goto op_semantics_50;
7537                   break;
7538               }
7539             break;
7540           case 0x1a:
7541               GETBYTE ();
7542               switch (op[2] & 0x00)
7543               {
7544                 case 0x00:
7545                   goto op_semantics_50;
7546                   break;
7547               }
7548             break;
7549           case 0x1b:
7550               GETBYTE ();
7551               switch (op[2] & 0x00)
7552               {
7553                 case 0x00:
7554                   goto op_semantics_50;
7555                   break;
7556               }
7557             break;
7558           case 0x1c:
7559               GETBYTE ();
7560               switch (op[2] & 0x00)
7561               {
7562                 case 0x00:
7563                   op_semantics_51:
7564                     {
7565                       /** 1111 1100 0001 11ss rsrc rdst emulu   %1%S1, %0 */
7566 #line 673 "rx-decode.opc"
7567                       int ss AU = op[1] & 0x03;
7568 #line 673 "rx-decode.opc"
7569                       int rsrc AU = (op[2] >> 4) & 0x0f;
7570 #line 673 "rx-decode.opc"
7571                       int rdst AU = op[2] & 0x0f;
7572                       if (trace)
7573                         {
7574                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7575                                  "/** 1111 1100 0001 11ss rsrc rdst     emulu   %1%S1, %0 */",
7576                                  op[0], op[1], op[2]);
7577                           printf ("  ss = 0x%x,", ss);
7578                           printf ("  rsrc = 0x%x,", rsrc);
7579                           printf ("  rdst = 0x%x\n", rdst);
7580                         }
7581                       SYNTAX("emulu     %1%S1, %0");
7582 #line 673 "rx-decode.opc"
7583                       ID(emulu); SP(ss, rsrc); DR(rdst);
7584
7585                     }
7586                   break;
7587               }
7588             break;
7589           case 0x1d:
7590               GETBYTE ();
7591               switch (op[2] & 0x00)
7592               {
7593                 case 0x00:
7594                   goto op_semantics_51;
7595                   break;
7596               }
7597             break;
7598           case 0x1e:
7599               GETBYTE ();
7600               switch (op[2] & 0x00)
7601               {
7602                 case 0x00:
7603                   goto op_semantics_51;
7604                   break;
7605               }
7606             break;
7607           case 0x1f:
7608               GETBYTE ();
7609               switch (op[2] & 0x00)
7610               {
7611                 case 0x00:
7612                   goto op_semantics_51;
7613                   break;
7614               }
7615             break;
7616           case 0x20:
7617               GETBYTE ();
7618               switch (op[2] & 0x00)
7619               {
7620                 case 0x00:
7621                   op_semantics_52:
7622                     {
7623                       /** 1111 1100 0010 00ss rsrc rdst div     %1%S1, %0 */
7624 #line 685 "rx-decode.opc"
7625                       int ss AU = op[1] & 0x03;
7626 #line 685 "rx-decode.opc"
7627                       int rsrc AU = (op[2] >> 4) & 0x0f;
7628 #line 685 "rx-decode.opc"
7629                       int rdst AU = op[2] & 0x0f;
7630                       if (trace)
7631                         {
7632                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7633                                  "/** 1111 1100 0010 00ss rsrc rdst     div     %1%S1, %0 */",
7634                                  op[0], op[1], op[2]);
7635                           printf ("  ss = 0x%x,", ss);
7636                           printf ("  rsrc = 0x%x,", rsrc);
7637                           printf ("  rdst = 0x%x\n", rdst);
7638                         }
7639                       SYNTAX("div       %1%S1, %0");
7640 #line 685 "rx-decode.opc"
7641                       ID(div); SP(ss, rsrc); DR(rdst); F_O___;
7642
7643                     }
7644                   break;
7645               }
7646             break;
7647           case 0x21:
7648               GETBYTE ();
7649               switch (op[2] & 0x00)
7650               {
7651                 case 0x00:
7652                   goto op_semantics_52;
7653                   break;
7654               }
7655             break;
7656           case 0x22:
7657               GETBYTE ();
7658               switch (op[2] & 0x00)
7659               {
7660                 case 0x00:
7661                   goto op_semantics_52;
7662                   break;
7663               }
7664             break;
7665           case 0x23:
7666               GETBYTE ();
7667               switch (op[2] & 0x00)
7668               {
7669                 case 0x00:
7670                   goto op_semantics_52;
7671                   break;
7672               }
7673             break;
7674           case 0x24:
7675               GETBYTE ();
7676               switch (op[2] & 0x00)
7677               {
7678                 case 0x00:
7679                   op_semantics_53:
7680                     {
7681                       /** 1111 1100 0010 01ss rsrc rdst divu    %1%S1, %0 */
7682 #line 697 "rx-decode.opc"
7683                       int ss AU = op[1] & 0x03;
7684 #line 697 "rx-decode.opc"
7685                       int rsrc AU = (op[2] >> 4) & 0x0f;
7686 #line 697 "rx-decode.opc"
7687                       int rdst AU = op[2] & 0x0f;
7688                       if (trace)
7689                         {
7690                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7691                                  "/** 1111 1100 0010 01ss rsrc rdst     divu    %1%S1, %0 */",
7692                                  op[0], op[1], op[2]);
7693                           printf ("  ss = 0x%x,", ss);
7694                           printf ("  rsrc = 0x%x,", rsrc);
7695                           printf ("  rdst = 0x%x\n", rdst);
7696                         }
7697                       SYNTAX("divu      %1%S1, %0");
7698 #line 697 "rx-decode.opc"
7699                       ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
7700
7701                     }
7702                   break;
7703               }
7704             break;
7705           case 0x25:
7706               GETBYTE ();
7707               switch (op[2] & 0x00)
7708               {
7709                 case 0x00:
7710                   goto op_semantics_53;
7711                   break;
7712               }
7713             break;
7714           case 0x26:
7715               GETBYTE ();
7716               switch (op[2] & 0x00)
7717               {
7718                 case 0x00:
7719                   goto op_semantics_53;
7720                   break;
7721               }
7722             break;
7723           case 0x27:
7724               GETBYTE ();
7725               switch (op[2] & 0x00)
7726               {
7727                 case 0x00:
7728                   goto op_semantics_53;
7729                   break;
7730               }
7731             break;
7732           case 0x30:
7733               GETBYTE ();
7734               switch (op[2] & 0x00)
7735               {
7736                 case 0x00:
7737                   op_semantics_54:
7738                     {
7739                       /** 1111 1100 0011 00ss rsrc rdst tst     %1%S1, %2 */
7740 #line 470 "rx-decode.opc"
7741                       int ss AU = op[1] & 0x03;
7742 #line 470 "rx-decode.opc"
7743                       int rsrc AU = (op[2] >> 4) & 0x0f;
7744 #line 470 "rx-decode.opc"
7745                       int rdst AU = op[2] & 0x0f;
7746                       if (trace)
7747                         {
7748                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7749                                  "/** 1111 1100 0011 00ss rsrc rdst     tst     %1%S1, %2 */",
7750                                  op[0], op[1], op[2]);
7751                           printf ("  ss = 0x%x,", ss);
7752                           printf ("  rsrc = 0x%x,", rsrc);
7753                           printf ("  rdst = 0x%x\n", rdst);
7754                         }
7755                       SYNTAX("tst       %1%S1, %2");
7756 #line 470 "rx-decode.opc"
7757                       ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
7758
7759                     }
7760                   break;
7761               }
7762             break;
7763           case 0x31:
7764               GETBYTE ();
7765               switch (op[2] & 0x00)
7766               {
7767                 case 0x00:
7768                   goto op_semantics_54;
7769                   break;
7770               }
7771             break;
7772           case 0x32:
7773               GETBYTE ();
7774               switch (op[2] & 0x00)
7775               {
7776                 case 0x00:
7777                   goto op_semantics_54;
7778                   break;
7779               }
7780             break;
7781           case 0x33:
7782               GETBYTE ();
7783               switch (op[2] & 0x00)
7784               {
7785                 case 0x00:
7786                   goto op_semantics_54;
7787                   break;
7788               }
7789             break;
7790           case 0x34:
7791               GETBYTE ();
7792               switch (op[2] & 0x00)
7793               {
7794                 case 0x00:
7795                   op_semantics_55:
7796                     {
7797                       /** 1111 1100 0011 01ss rsrc rdst xor     %1%S1, %0 */
7798 #line 449 "rx-decode.opc"
7799                       int ss AU = op[1] & 0x03;
7800 #line 449 "rx-decode.opc"
7801                       int rsrc AU = (op[2] >> 4) & 0x0f;
7802 #line 449 "rx-decode.opc"
7803                       int rdst AU = op[2] & 0x0f;
7804                       if (trace)
7805                         {
7806                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7807                                  "/** 1111 1100 0011 01ss rsrc rdst     xor     %1%S1, %0 */",
7808                                  op[0], op[1], op[2]);
7809                           printf ("  ss = 0x%x,", ss);
7810                           printf ("  rsrc = 0x%x,", rsrc);
7811                           printf ("  rdst = 0x%x\n", rdst);
7812                         }
7813                       SYNTAX("xor       %1%S1, %0");
7814 #line 449 "rx-decode.opc"
7815                       ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
7816
7817                     }
7818                   break;
7819               }
7820             break;
7821           case 0x35:
7822               GETBYTE ();
7823               switch (op[2] & 0x00)
7824               {
7825                 case 0x00:
7826                   goto op_semantics_55;
7827                   break;
7828               }
7829             break;
7830           case 0x36:
7831               GETBYTE ();
7832               switch (op[2] & 0x00)
7833               {
7834                 case 0x00:
7835                   goto op_semantics_55;
7836                   break;
7837               }
7838             break;
7839           case 0x37:
7840               GETBYTE ();
7841               switch (op[2] & 0x00)
7842               {
7843                 case 0x00:
7844                   goto op_semantics_55;
7845                   break;
7846               }
7847             break;
7848           case 0x3b:
7849               GETBYTE ();
7850               switch (op[2] & 0x00)
7851               {
7852                 case 0x00:
7853                     {
7854                       /** 1111 1100 0011 1011 rsrc rdst not     %1, %0 */
7855 #line 461 "rx-decode.opc"
7856                       int rsrc AU = (op[2] >> 4) & 0x0f;
7857 #line 461 "rx-decode.opc"
7858                       int rdst AU = op[2] & 0x0f;
7859                       if (trace)
7860                         {
7861                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7862                                  "/** 1111 1100 0011 1011 rsrc rdst     not     %1, %0 */",
7863                                  op[0], op[1], op[2]);
7864                           printf ("  rsrc = 0x%x,", rsrc);
7865                           printf ("  rdst = 0x%x\n", rdst);
7866                         }
7867                       SYNTAX("not       %1, %0");
7868 #line 461 "rx-decode.opc"
7869                       ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
7870
7871                     /*----------------------------------------------------------------------*/
7872                     /* TST                                                                      */
7873
7874                     }
7875                   break;
7876               }
7877             break;
7878           case 0x40:
7879               GETBYTE ();
7880               switch (op[2] & 0x00)
7881               {
7882                 case 0x00:
7883                   op_semantics_56:
7884                     {
7885                       /** 1111 1100 0100 00ss rsrc rdst xchg    %1%S1, %0 */
7886 #line 383 "rx-decode.opc"
7887                       int ss AU = op[1] & 0x03;
7888 #line 383 "rx-decode.opc"
7889                       int rsrc AU = (op[2] >> 4) & 0x0f;
7890 #line 383 "rx-decode.opc"
7891                       int rdst AU = op[2] & 0x0f;
7892                       if (trace)
7893                         {
7894                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7895                                  "/** 1111 1100 0100 00ss rsrc rdst     xchg    %1%S1, %0 */",
7896                                  op[0], op[1], op[2]);
7897                           printf ("  ss = 0x%x,", ss);
7898                           printf ("  rsrc = 0x%x,", rsrc);
7899                           printf ("  rdst = 0x%x\n", rdst);
7900                         }
7901                       SYNTAX("xchg      %1%S1, %0");
7902 #line 383 "rx-decode.opc"
7903                       ID(xchg); DR(rdst); SP(ss, rsrc);
7904
7905                     }
7906                   break;
7907               }
7908             break;
7909           case 0x41:
7910               GETBYTE ();
7911               switch (op[2] & 0x00)
7912               {
7913                 case 0x00:
7914                   goto op_semantics_56;
7915                   break;
7916               }
7917             break;
7918           case 0x42:
7919               GETBYTE ();
7920               switch (op[2] & 0x00)
7921               {
7922                 case 0x00:
7923                   goto op_semantics_56;
7924                   break;
7925               }
7926             break;
7927           case 0x43:
7928               GETBYTE ();
7929               switch (op[2] & 0x00)
7930               {
7931                 case 0x00:
7932                   goto op_semantics_56;
7933                   break;
7934               }
7935             break;
7936           case 0x44:
7937               GETBYTE ();
7938               switch (op[2] & 0x00)
7939               {
7940                 case 0x00:
7941                   op_semantics_57:
7942                     {
7943                       /** 1111 1100 0100 01sd rsrc rdst itof    %1%S1, %0 */
7944 #line 926 "rx-decode.opc"
7945                       int sd AU = op[1] & 0x03;
7946 #line 926 "rx-decode.opc"
7947                       int rsrc AU = (op[2] >> 4) & 0x0f;
7948 #line 926 "rx-decode.opc"
7949                       int rdst AU = op[2] & 0x0f;
7950                       if (trace)
7951                         {
7952                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7953                                  "/** 1111 1100 0100 01sd rsrc rdst     itof    %1%S1, %0 */",
7954                                  op[0], op[1], op[2]);
7955                           printf ("  sd = 0x%x,", sd);
7956                           printf ("  rsrc = 0x%x,", rsrc);
7957                           printf ("  rdst = 0x%x\n", rdst);
7958                         }
7959                       SYNTAX("itof      %1%S1, %0");
7960 #line 926 "rx-decode.opc"
7961                       ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
7962
7963                     }
7964                   break;
7965               }
7966             break;
7967           case 0x45:
7968               GETBYTE ();
7969               switch (op[2] & 0x00)
7970               {
7971                 case 0x00:
7972                   goto op_semantics_57;
7973                   break;
7974               }
7975             break;
7976           case 0x46:
7977               GETBYTE ();
7978               switch (op[2] & 0x00)
7979               {
7980                 case 0x00:
7981                   goto op_semantics_57;
7982                   break;
7983               }
7984             break;
7985           case 0x47:
7986               GETBYTE ();
7987               switch (op[2] & 0x00)
7988               {
7989                 case 0x00:
7990                   goto op_semantics_57;
7991                   break;
7992               }
7993             break;
7994           case 0x4b:
7995               GETBYTE ();
7996               switch (op[2] & 0x00)
7997               {
7998                 case 0x00:
7999                     {
8000                       /** 1111 1100 0100 1011 rsrc rdst stz     %1, %0 */
8001 #line 1052 "rx-decode.opc"
8002                       int rsrc AU = (op[2] >> 4) & 0x0f;
8003 #line 1052 "rx-decode.opc"
8004                       int rdst AU = op[2] & 0x0f;
8005                       if (trace)
8006                         {
8007                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8008                                  "/** 1111 1100 0100 1011 rsrc rdst     stz     %1, %0 */",
8009                                  op[0], op[1], op[2]);
8010                           printf ("  rsrc = 0x%x,", rsrc);
8011                           printf ("  rdst = 0x%x\n", rdst);
8012                         }
8013                       SYNTAX("stz       %1, %0");
8014 #line 1052 "rx-decode.opc"
8015                       ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
8016
8017                     }
8018                   break;
8019               }
8020             break;
8021           case 0x4f:
8022               GETBYTE ();
8023               switch (op[2] & 0x00)
8024               {
8025                 case 0x00:
8026                     {
8027                       /** 1111 1100 0100 1111 rsrc rdst stnz    %1, %0 */
8028 #line 1055 "rx-decode.opc"
8029                       int rsrc AU = (op[2] >> 4) & 0x0f;
8030 #line 1055 "rx-decode.opc"
8031                       int rdst AU = op[2] & 0x0f;
8032                       if (trace)
8033                         {
8034                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8035                                  "/** 1111 1100 0100 1111 rsrc rdst     stnz    %1, %0 */",
8036                                  op[0], op[1], op[2]);
8037                           printf ("  rsrc = 0x%x,", rsrc);
8038                           printf ("  rdst = 0x%x\n", rdst);
8039                         }
8040                       SYNTAX("stnz      %1, %0");
8041 #line 1055 "rx-decode.opc"
8042                       ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
8043
8044                     }
8045                   break;
8046               }
8047             break;
8048           case 0x54:
8049               GETBYTE ();
8050               switch (op[2] & 0x00)
8051               {
8052                 case 0x00:
8053                   op_semantics_58:
8054                     {
8055                       /** 1111 1100 0101 01sd rsrc rdst utof    %1%S1, %0 */
8056 #line 1112 "rx-decode.opc"
8057                       int sd AU = op[1] & 0x03;
8058 #line 1112 "rx-decode.opc"
8059                       int rsrc AU = (op[2] >> 4) & 0x0f;
8060 #line 1112 "rx-decode.opc"
8061                       int rdst AU = op[2] & 0x0f;
8062                       if (trace)
8063                         {
8064                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8065                                  "/** 1111 1100 0101 01sd rsrc rdst     utof    %1%S1, %0 */",
8066                                  op[0], op[1], op[2]);
8067                           printf ("  sd = 0x%x,", sd);
8068                           printf ("  rsrc = 0x%x,", rsrc);
8069                           printf ("  rdst = 0x%x\n", rdst);
8070                         }
8071                       SYNTAX("utof      %1%S1, %0");
8072 #line 1112 "rx-decode.opc"
8073                       ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
8074
8075                     }
8076                   break;
8077               }
8078             break;
8079           case 0x55:
8080               GETBYTE ();
8081               switch (op[2] & 0x00)
8082               {
8083                 case 0x00:
8084                   goto op_semantics_58;
8085                   break;
8086               }
8087             break;
8088           case 0x56:
8089               GETBYTE ();
8090               switch (op[2] & 0x00)
8091               {
8092                 case 0x00:
8093                   goto op_semantics_58;
8094                   break;
8095               }
8096             break;
8097           case 0x57:
8098               GETBYTE ();
8099               switch (op[2] & 0x00)
8100               {
8101                 case 0x00:
8102                   goto op_semantics_58;
8103                   break;
8104               }
8105             break;
8106           case 0x60:
8107               GETBYTE ();
8108               switch (op[2] & 0x00)
8109               {
8110                 case 0x00:
8111                   op_semantics_59:
8112                     {
8113                       /** 1111 1100 0110 00sd rdst rsrc bset    %1, %0%S0 */
8114 #line 938 "rx-decode.opc"
8115                       int sd AU = op[1] & 0x03;
8116 #line 938 "rx-decode.opc"
8117                       int rdst AU = (op[2] >> 4) & 0x0f;
8118 #line 938 "rx-decode.opc"
8119                       int rsrc AU = op[2] & 0x0f;
8120                       if (trace)
8121                         {
8122                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8123                                  "/** 1111 1100 0110 00sd rdst rsrc     bset    %1, %0%S0 */",
8124                                  op[0], op[1], op[2]);
8125                           printf ("  sd = 0x%x,", sd);
8126                           printf ("  rdst = 0x%x,", rdst);
8127                           printf ("  rsrc = 0x%x\n", rsrc);
8128                         }
8129                       SYNTAX("bset      %1, %0%S0");
8130 #line 938 "rx-decode.opc"
8131                       ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8132                       if (sd == 3) /* bset reg,reg */
8133                         BWL(LSIZE);
8134
8135                     }
8136                   break;
8137               }
8138             break;
8139           case 0x61:
8140               GETBYTE ();
8141               switch (op[2] & 0x00)
8142               {
8143                 case 0x00:
8144                   goto op_semantics_59;
8145                   break;
8146               }
8147             break;
8148           case 0x62:
8149               GETBYTE ();
8150               switch (op[2] & 0x00)
8151               {
8152                 case 0x00:
8153                   goto op_semantics_59;
8154                   break;
8155               }
8156             break;
8157           case 0x63:
8158               GETBYTE ();
8159               switch (op[2] & 0x00)
8160               {
8161                 case 0x00:
8162                   goto op_semantics_59;
8163                   break;
8164               }
8165             break;
8166           case 0x64:
8167               GETBYTE ();
8168               switch (op[2] & 0x00)
8169               {
8170                 case 0x00:
8171                   op_semantics_60:
8172                     {
8173                       /** 1111 1100 0110 01sd rdst rsrc bclr    %1, %0%S0 */
8174 #line 950 "rx-decode.opc"
8175                       int sd AU = op[1] & 0x03;
8176 #line 950 "rx-decode.opc"
8177                       int rdst AU = (op[2] >> 4) & 0x0f;
8178 #line 950 "rx-decode.opc"
8179                       int rsrc AU = op[2] & 0x0f;
8180                       if (trace)
8181                         {
8182                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8183                                  "/** 1111 1100 0110 01sd rdst rsrc     bclr    %1, %0%S0 */",
8184                                  op[0], op[1], op[2]);
8185                           printf ("  sd = 0x%x,", sd);
8186                           printf ("  rdst = 0x%x,", rdst);
8187                           printf ("  rsrc = 0x%x\n", rsrc);
8188                         }
8189                       SYNTAX("bclr      %1, %0%S0");
8190 #line 950 "rx-decode.opc"
8191                       ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
8192                       if (sd == 3) /* bset reg,reg */
8193                         BWL(LSIZE);
8194
8195                     }
8196                   break;
8197               }
8198             break;
8199           case 0x65:
8200               GETBYTE ();
8201               switch (op[2] & 0x00)
8202               {
8203                 case 0x00:
8204                   goto op_semantics_60;
8205                   break;
8206               }
8207             break;
8208           case 0x66:
8209               GETBYTE ();
8210               switch (op[2] & 0x00)
8211               {
8212                 case 0x00:
8213                   goto op_semantics_60;
8214                   break;
8215               }
8216             break;
8217           case 0x67:
8218               GETBYTE ();
8219               switch (op[2] & 0x00)
8220               {
8221                 case 0x00:
8222                   goto op_semantics_60;
8223                   break;
8224               }
8225             break;
8226           case 0x68:
8227               GETBYTE ();
8228               switch (op[2] & 0x00)
8229               {
8230                 case 0x00:
8231                   op_semantics_61:
8232                     {
8233                       /** 1111 1100 0110 10sd rdst rsrc btst    %2, %1%S1 */
8234 #line 962 "rx-decode.opc"
8235                       int sd AU = op[1] & 0x03;
8236 #line 962 "rx-decode.opc"
8237                       int rdst AU = (op[2] >> 4) & 0x0f;
8238 #line 962 "rx-decode.opc"
8239                       int rsrc AU = op[2] & 0x0f;
8240                       if (trace)
8241                         {
8242                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8243                                  "/** 1111 1100 0110 10sd rdst rsrc     btst    %2, %1%S1 */",
8244                                  op[0], op[1], op[2]);
8245                           printf ("  sd = 0x%x,", sd);
8246                           printf ("  rdst = 0x%x,", rdst);
8247                           printf ("  rsrc = 0x%x\n", rsrc);
8248                         }
8249                       SYNTAX("btst      %2, %1%S1");
8250 #line 962 "rx-decode.opc"
8251                       ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
8252                       if (sd == 3) /* bset reg,reg */
8253                         BWL(LSIZE);
8254
8255                     }
8256                   break;
8257               }
8258             break;
8259           case 0x69:
8260               GETBYTE ();
8261               switch (op[2] & 0x00)
8262               {
8263                 case 0x00:
8264                   goto op_semantics_61;
8265                   break;
8266               }
8267             break;
8268           case 0x6a:
8269               GETBYTE ();
8270               switch (op[2] & 0x00)
8271               {
8272                 case 0x00:
8273                   goto op_semantics_61;
8274                   break;
8275               }
8276             break;
8277           case 0x6b:
8278               GETBYTE ();
8279               switch (op[2] & 0x00)
8280               {
8281                 case 0x00:
8282                   goto op_semantics_61;
8283                   break;
8284               }
8285             break;
8286           case 0x6c:
8287               GETBYTE ();
8288               switch (op[2] & 0x00)
8289               {
8290                 case 0x00:
8291                   op_semantics_62:
8292                     {
8293                       /** 1111 1100 0110 11sd rdst rsrc bnot    %1, %0%S0 */
8294 #line 974 "rx-decode.opc"
8295                       int sd AU = op[1] & 0x03;
8296 #line 974 "rx-decode.opc"
8297                       int rdst AU = (op[2] >> 4) & 0x0f;
8298 #line 974 "rx-decode.opc"
8299                       int rsrc AU = op[2] & 0x0f;
8300                       if (trace)
8301                         {
8302                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8303                                  "/** 1111 1100 0110 11sd rdst rsrc     bnot    %1, %0%S0 */",
8304                                  op[0], op[1], op[2]);
8305                           printf ("  sd = 0x%x,", sd);
8306                           printf ("  rdst = 0x%x,", rdst);
8307                           printf ("  rsrc = 0x%x\n", rsrc);
8308                         }
8309                       SYNTAX("bnot      %1, %0%S0");
8310 #line 974 "rx-decode.opc"
8311                       ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
8312                       if (sd == 3) /* bset reg,reg */
8313                         BWL(LSIZE);
8314
8315                     }
8316                   break;
8317               }
8318             break;
8319           case 0x6d:
8320               GETBYTE ();
8321               switch (op[2] & 0x00)
8322               {
8323                 case 0x00:
8324                   goto op_semantics_62;
8325                   break;
8326               }
8327             break;
8328           case 0x6e:
8329               GETBYTE ();
8330               switch (op[2] & 0x00)
8331               {
8332                 case 0x00:
8333                   goto op_semantics_62;
8334                   break;
8335               }
8336             break;
8337           case 0x6f:
8338               GETBYTE ();
8339               switch (op[2] & 0x00)
8340               {
8341                 case 0x00:
8342                   goto op_semantics_62;
8343                   break;
8344               }
8345             break;
8346           case 0x80:
8347               GETBYTE ();
8348               switch (op[2] & 0x00)
8349               {
8350                 case 0x00:
8351                   op_semantics_63:
8352                     {
8353                       /** 1111 1100 1000 00sd rsrc rdst fsub    %1%S1, %0 */
8354 #line 905 "rx-decode.opc"
8355                       int sd AU = op[1] & 0x03;
8356 #line 905 "rx-decode.opc"
8357                       int rsrc AU = (op[2] >> 4) & 0x0f;
8358 #line 905 "rx-decode.opc"
8359                       int rdst AU = op[2] & 0x0f;
8360                       if (trace)
8361                         {
8362                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8363                                  "/** 1111 1100 1000 00sd rsrc rdst     fsub    %1%S1, %0 */",
8364                                  op[0], op[1], op[2]);
8365                           printf ("  sd = 0x%x,", sd);
8366                           printf ("  rsrc = 0x%x,", rsrc);
8367                           printf ("  rdst = 0x%x\n", rdst);
8368                         }
8369                       SYNTAX("fsub      %1%S1, %0");
8370 #line 905 "rx-decode.opc"
8371                       ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8372
8373                     }
8374                   break;
8375               }
8376             break;
8377           case 0x81:
8378               GETBYTE ();
8379               switch (op[2] & 0x00)
8380               {
8381                 case 0x00:
8382                   goto op_semantics_63;
8383                   break;
8384               }
8385             break;
8386           case 0x82:
8387               GETBYTE ();
8388               switch (op[2] & 0x00)
8389               {
8390                 case 0x00:
8391                   goto op_semantics_63;
8392                   break;
8393               }
8394             break;
8395           case 0x83:
8396               GETBYTE ();
8397               switch (op[2] & 0x00)
8398               {
8399                 case 0x00:
8400                   goto op_semantics_63;
8401                   break;
8402               }
8403             break;
8404           case 0x84:
8405               GETBYTE ();
8406               switch (op[2] & 0x00)
8407               {
8408                 case 0x00:
8409                   op_semantics_64:
8410                     {
8411                       /** 1111 1100 1000 01sd rsrc rdst fcmp    %1%S1, %0 */
8412 #line 899 "rx-decode.opc"
8413                       int sd AU = op[1] & 0x03;
8414 #line 899 "rx-decode.opc"
8415                       int rsrc AU = (op[2] >> 4) & 0x0f;
8416 #line 899 "rx-decode.opc"
8417                       int rdst AU = op[2] & 0x0f;
8418                       if (trace)
8419                         {
8420                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8421                                  "/** 1111 1100 1000 01sd rsrc rdst     fcmp    %1%S1, %0 */",
8422                                  op[0], op[1], op[2]);
8423                           printf ("  sd = 0x%x,", sd);
8424                           printf ("  rsrc = 0x%x,", rsrc);
8425                           printf ("  rdst = 0x%x\n", rdst);
8426                         }
8427                       SYNTAX("fcmp      %1%S1, %0");
8428 #line 899 "rx-decode.opc"
8429                       ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
8430
8431                     }
8432                   break;
8433               }
8434             break;
8435           case 0x85:
8436               GETBYTE ();
8437               switch (op[2] & 0x00)
8438               {
8439                 case 0x00:
8440                   goto op_semantics_64;
8441                   break;
8442               }
8443             break;
8444           case 0x86:
8445               GETBYTE ();
8446               switch (op[2] & 0x00)
8447               {
8448                 case 0x00:
8449                   goto op_semantics_64;
8450                   break;
8451               }
8452             break;
8453           case 0x87:
8454               GETBYTE ();
8455               switch (op[2] & 0x00)
8456               {
8457                 case 0x00:
8458                   goto op_semantics_64;
8459                   break;
8460               }
8461             break;
8462           case 0x88:
8463               GETBYTE ();
8464               switch (op[2] & 0x00)
8465               {
8466                 case 0x00:
8467                   op_semantics_65:
8468                     {
8469                       /** 1111 1100 1000 10sd rsrc rdst fadd    %1%S1, %0 */
8470 #line 893 "rx-decode.opc"
8471                       int sd AU = op[1] & 0x03;
8472 #line 893 "rx-decode.opc"
8473                       int rsrc AU = (op[2] >> 4) & 0x0f;
8474 #line 893 "rx-decode.opc"
8475                       int rdst AU = op[2] & 0x0f;
8476                       if (trace)
8477                         {
8478                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8479                                  "/** 1111 1100 1000 10sd rsrc rdst     fadd    %1%S1, %0 */",
8480                                  op[0], op[1], op[2]);
8481                           printf ("  sd = 0x%x,", sd);
8482                           printf ("  rsrc = 0x%x,", rsrc);
8483                           printf ("  rdst = 0x%x\n", rdst);
8484                         }
8485                       SYNTAX("fadd      %1%S1, %0");
8486 #line 893 "rx-decode.opc"
8487                       ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8488
8489                     }
8490                   break;
8491               }
8492             break;
8493           case 0x89:
8494               GETBYTE ();
8495               switch (op[2] & 0x00)
8496               {
8497                 case 0x00:
8498                   goto op_semantics_65;
8499                   break;
8500               }
8501             break;
8502           case 0x8a:
8503               GETBYTE ();
8504               switch (op[2] & 0x00)
8505               {
8506                 case 0x00:
8507                   goto op_semantics_65;
8508                   break;
8509               }
8510             break;
8511           case 0x8b:
8512               GETBYTE ();
8513               switch (op[2] & 0x00)
8514               {
8515                 case 0x00:
8516                   goto op_semantics_65;
8517                   break;
8518               }
8519             break;
8520           case 0x8c:
8521               GETBYTE ();
8522               switch (op[2] & 0x00)
8523               {
8524                 case 0x00:
8525                   op_semantics_66:
8526                     {
8527                       /** 1111 1100 1000 11sd rsrc rdst fmul    %1%S1, %0 */
8528 #line 914 "rx-decode.opc"
8529                       int sd AU = op[1] & 0x03;
8530 #line 914 "rx-decode.opc"
8531                       int rsrc AU = (op[2] >> 4) & 0x0f;
8532 #line 914 "rx-decode.opc"
8533                       int rdst AU = op[2] & 0x0f;
8534                       if (trace)
8535                         {
8536                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8537                                  "/** 1111 1100 1000 11sd rsrc rdst     fmul    %1%S1, %0 */",
8538                                  op[0], op[1], op[2]);
8539                           printf ("  sd = 0x%x,", sd);
8540                           printf ("  rsrc = 0x%x,", rsrc);
8541                           printf ("  rdst = 0x%x\n", rdst);
8542                         }
8543                       SYNTAX("fmul      %1%S1, %0");
8544 #line 914 "rx-decode.opc"
8545                       ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8546
8547                     }
8548                   break;
8549               }
8550             break;
8551           case 0x8d:
8552               GETBYTE ();
8553               switch (op[2] & 0x00)
8554               {
8555                 case 0x00:
8556                   goto op_semantics_66;
8557                   break;
8558               }
8559             break;
8560           case 0x8e:
8561               GETBYTE ();
8562               switch (op[2] & 0x00)
8563               {
8564                 case 0x00:
8565                   goto op_semantics_66;
8566                   break;
8567               }
8568             break;
8569           case 0x8f:
8570               GETBYTE ();
8571               switch (op[2] & 0x00)
8572               {
8573                 case 0x00:
8574                   goto op_semantics_66;
8575                   break;
8576               }
8577             break;
8578           case 0x90:
8579               GETBYTE ();
8580               switch (op[2] & 0x00)
8581               {
8582                 case 0x00:
8583                   op_semantics_67:
8584                     {
8585                       /** 1111 1100 1001 00sd rsrc rdst fdiv    %1%S1, %0 */
8586 #line 920 "rx-decode.opc"
8587                       int sd AU = op[1] & 0x03;
8588 #line 920 "rx-decode.opc"
8589                       int rsrc AU = (op[2] >> 4) & 0x0f;
8590 #line 920 "rx-decode.opc"
8591                       int rdst AU = op[2] & 0x0f;
8592                       if (trace)
8593                         {
8594                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8595                                  "/** 1111 1100 1001 00sd rsrc rdst     fdiv    %1%S1, %0 */",
8596                                  op[0], op[1], op[2]);
8597                           printf ("  sd = 0x%x,", sd);
8598                           printf ("  rsrc = 0x%x,", rsrc);
8599                           printf ("  rdst = 0x%x\n", rdst);
8600                         }
8601                       SYNTAX("fdiv      %1%S1, %0");
8602 #line 920 "rx-decode.opc"
8603                       ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8604
8605                     }
8606                   break;
8607               }
8608             break;
8609           case 0x91:
8610               GETBYTE ();
8611               switch (op[2] & 0x00)
8612               {
8613                 case 0x00:
8614                   goto op_semantics_67;
8615                   break;
8616               }
8617             break;
8618           case 0x92:
8619               GETBYTE ();
8620               switch (op[2] & 0x00)
8621               {
8622                 case 0x00:
8623                   goto op_semantics_67;
8624                   break;
8625               }
8626             break;
8627           case 0x93:
8628               GETBYTE ();
8629               switch (op[2] & 0x00)
8630               {
8631                 case 0x00:
8632                   goto op_semantics_67;
8633                   break;
8634               }
8635             break;
8636           case 0x94:
8637               GETBYTE ();
8638               switch (op[2] & 0x00)
8639               {
8640                 case 0x00:
8641                   op_semantics_68:
8642                     {
8643                       /** 1111 1100 1001 01sd rsrc rdst ftoi    %1%S1, %0 */
8644 #line 908 "rx-decode.opc"
8645                       int sd AU = op[1] & 0x03;
8646 #line 908 "rx-decode.opc"
8647                       int rsrc AU = (op[2] >> 4) & 0x0f;
8648 #line 908 "rx-decode.opc"
8649                       int rdst AU = op[2] & 0x0f;
8650                       if (trace)
8651                         {
8652                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8653                                  "/** 1111 1100 1001 01sd rsrc rdst     ftoi    %1%S1, %0 */",
8654                                  op[0], op[1], op[2]);
8655                           printf ("  sd = 0x%x,", sd);
8656                           printf ("  rsrc = 0x%x,", rsrc);
8657                           printf ("  rdst = 0x%x\n", rdst);
8658                         }
8659                       SYNTAX("ftoi      %1%S1, %0");
8660 #line 908 "rx-decode.opc"
8661                       ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8662
8663                     }
8664                   break;
8665               }
8666             break;
8667           case 0x95:
8668               GETBYTE ();
8669               switch (op[2] & 0x00)
8670               {
8671                 case 0x00:
8672                   goto op_semantics_68;
8673                   break;
8674               }
8675             break;
8676           case 0x96:
8677               GETBYTE ();
8678               switch (op[2] & 0x00)
8679               {
8680                 case 0x00:
8681                   goto op_semantics_68;
8682                   break;
8683               }
8684             break;
8685           case 0x97:
8686               GETBYTE ();
8687               switch (op[2] & 0x00)
8688               {
8689                 case 0x00:
8690                   goto op_semantics_68;
8691                   break;
8692               }
8693             break;
8694           case 0x98:
8695               GETBYTE ();
8696               switch (op[2] & 0x00)
8697               {
8698                 case 0x00:
8699                   op_semantics_69:
8700                     {
8701                       /** 1111 1100 1001 10sd rsrc rdst round   %1%S1, %0 */
8702 #line 923 "rx-decode.opc"
8703                       int sd AU = op[1] & 0x03;
8704 #line 923 "rx-decode.opc"
8705                       int rsrc AU = (op[2] >> 4) & 0x0f;
8706 #line 923 "rx-decode.opc"
8707                       int rdst AU = op[2] & 0x0f;
8708                       if (trace)
8709                         {
8710                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8711                                  "/** 1111 1100 1001 10sd rsrc rdst     round   %1%S1, %0 */",
8712                                  op[0], op[1], op[2]);
8713                           printf ("  sd = 0x%x,", sd);
8714                           printf ("  rsrc = 0x%x,", rsrc);
8715                           printf ("  rdst = 0x%x\n", rdst);
8716                         }
8717                       SYNTAX("round     %1%S1, %0");
8718 #line 923 "rx-decode.opc"
8719                       ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8720
8721                     }
8722                   break;
8723               }
8724             break;
8725           case 0x99:
8726               GETBYTE ();
8727               switch (op[2] & 0x00)
8728               {
8729                 case 0x00:
8730                   goto op_semantics_69;
8731                   break;
8732               }
8733             break;
8734           case 0x9a:
8735               GETBYTE ();
8736               switch (op[2] & 0x00)
8737               {
8738                 case 0x00:
8739                   goto op_semantics_69;
8740                   break;
8741               }
8742             break;
8743           case 0x9b:
8744               GETBYTE ();
8745               switch (op[2] & 0x00)
8746               {
8747                 case 0x00:
8748                   goto op_semantics_69;
8749                   break;
8750               }
8751             break;
8752           case 0xa0:
8753               GETBYTE ();
8754               switch (op[2] & 0x00)
8755               {
8756                 case 0x00:
8757                   op_semantics_70:
8758                     {
8759                       /** 1111 1100 1010 00sd rsrc rdst fsqrt   %1%S1, %0 */
8760 #line 1106 "rx-decode.opc"
8761                       int sd AU = op[1] & 0x03;
8762 #line 1106 "rx-decode.opc"
8763                       int rsrc AU = (op[2] >> 4) & 0x0f;
8764 #line 1106 "rx-decode.opc"
8765                       int rdst AU = op[2] & 0x0f;
8766                       if (trace)
8767                         {
8768                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8769                                  "/** 1111 1100 1010 00sd rsrc rdst     fsqrt   %1%S1, %0 */",
8770                                  op[0], op[1], op[2]);
8771                           printf ("  sd = 0x%x,", sd);
8772                           printf ("  rsrc = 0x%x,", rsrc);
8773                           printf ("  rdst = 0x%x\n", rdst);
8774                         }
8775                       SYNTAX("fsqrt     %1%S1, %0");
8776 #line 1106 "rx-decode.opc"
8777                       ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8778
8779                     }
8780                   break;
8781               }
8782             break;
8783           case 0xa1:
8784               GETBYTE ();
8785               switch (op[2] & 0x00)
8786               {
8787                 case 0x00:
8788                   goto op_semantics_70;
8789                   break;
8790               }
8791             break;
8792           case 0xa2:
8793               GETBYTE ();
8794               switch (op[2] & 0x00)
8795               {
8796                 case 0x00:
8797                   goto op_semantics_70;
8798                   break;
8799               }
8800             break;
8801           case 0xa3:
8802               GETBYTE ();
8803               switch (op[2] & 0x00)
8804               {
8805                 case 0x00:
8806                   goto op_semantics_70;
8807                   break;
8808               }
8809             break;
8810           case 0xa4:
8811               GETBYTE ();
8812               switch (op[2] & 0x00)
8813               {
8814                 case 0x00:
8815                   op_semantics_71:
8816                     {
8817                       /** 1111 1100 1010 01sd rsrc rdst ftou    %1%S1, %0 */
8818 #line 1109 "rx-decode.opc"
8819                       int sd AU = op[1] & 0x03;
8820 #line 1109 "rx-decode.opc"
8821                       int rsrc AU = (op[2] >> 4) & 0x0f;
8822 #line 1109 "rx-decode.opc"
8823                       int rdst AU = op[2] & 0x0f;
8824                       if (trace)
8825                         {
8826                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8827                                  "/** 1111 1100 1010 01sd rsrc rdst     ftou    %1%S1, %0 */",
8828                                  op[0], op[1], op[2]);
8829                           printf ("  sd = 0x%x,", sd);
8830                           printf ("  rsrc = 0x%x,", rsrc);
8831                           printf ("  rdst = 0x%x\n", rdst);
8832                         }
8833                       SYNTAX("ftou      %1%S1, %0");
8834 #line 1109 "rx-decode.opc"
8835                       ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8836
8837                     }
8838                   break;
8839               }
8840             break;
8841           case 0xa5:
8842               GETBYTE ();
8843               switch (op[2] & 0x00)
8844               {
8845                 case 0x00:
8846                   goto op_semantics_71;
8847                   break;
8848               }
8849             break;
8850           case 0xa6:
8851               GETBYTE ();
8852               switch (op[2] & 0x00)
8853               {
8854                 case 0x00:
8855                   goto op_semantics_71;
8856                   break;
8857               }
8858             break;
8859           case 0xa7:
8860               GETBYTE ();
8861               switch (op[2] & 0x00)
8862               {
8863                 case 0x00:
8864                   goto op_semantics_71;
8865                   break;
8866               }
8867             break;
8868           case 0xd0:
8869               GETBYTE ();
8870               switch (op[2] & 0x00)
8871               {
8872                 case 0x00:
8873                   op_semantics_72:
8874                     {
8875                       /** 1111 1100 1101 sz sd rdst cond        sc%1%s  %0 */
8876 #line 1040 "rx-decode.opc"
8877                       int sz AU = (op[1] >> 2) & 0x03;
8878 #line 1040 "rx-decode.opc"
8879                       int sd AU = op[1] & 0x03;
8880 #line 1040 "rx-decode.opc"
8881                       int rdst AU = (op[2] >> 4) & 0x0f;
8882 #line 1040 "rx-decode.opc"
8883                       int cond AU = op[2] & 0x0f;
8884                       if (trace)
8885                         {
8886                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8887                                  "/** 1111 1100 1101 sz sd rdst cond    sc%1%s  %0 */",
8888                                  op[0], op[1], op[2]);
8889                           printf ("  sz = 0x%x,", sz);
8890                           printf ("  sd = 0x%x,", sd);
8891                           printf ("  rdst = 0x%x,", rdst);
8892                           printf ("  cond = 0x%x\n", cond);
8893                         }
8894                       SYNTAX("sc%1%s    %0");
8895 #line 1040 "rx-decode.opc"
8896                       ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8897
8898                     /*----------------------------------------------------------------------*/
8899                     /* RXv2 enhanced                                                            */
8900
8901                     }
8902                   break;
8903               }
8904             break;
8905           case 0xd1:
8906               GETBYTE ();
8907               switch (op[2] & 0x00)
8908               {
8909                 case 0x00:
8910                   goto op_semantics_72;
8911                   break;
8912               }
8913             break;
8914           case 0xd2:
8915               GETBYTE ();
8916               switch (op[2] & 0x00)
8917               {
8918                 case 0x00:
8919                   goto op_semantics_72;
8920                   break;
8921               }
8922             break;
8923           case 0xd3:
8924               GETBYTE ();
8925               switch (op[2] & 0x00)
8926               {
8927                 case 0x00:
8928                   goto op_semantics_72;
8929                   break;
8930               }
8931             break;
8932           case 0xd4:
8933               GETBYTE ();
8934               switch (op[2] & 0x00)
8935               {
8936                 case 0x00:
8937                   goto op_semantics_72;
8938                   break;
8939               }
8940             break;
8941           case 0xd5:
8942               GETBYTE ();
8943               switch (op[2] & 0x00)
8944               {
8945                 case 0x00:
8946                   goto op_semantics_72;
8947                   break;
8948               }
8949             break;
8950           case 0xd6:
8951               GETBYTE ();
8952               switch (op[2] & 0x00)
8953               {
8954                 case 0x00:
8955                   goto op_semantics_72;
8956                   break;
8957               }
8958             break;
8959           case 0xd7:
8960               GETBYTE ();
8961               switch (op[2] & 0x00)
8962               {
8963                 case 0x00:
8964                   goto op_semantics_72;
8965                   break;
8966               }
8967             break;
8968           case 0xd8:
8969               GETBYTE ();
8970               switch (op[2] & 0x00)
8971               {
8972                 case 0x00:
8973                   goto op_semantics_72;
8974                   break;
8975               }
8976             break;
8977           case 0xd9:
8978               GETBYTE ();
8979               switch (op[2] & 0x00)
8980               {
8981                 case 0x00:
8982                   goto op_semantics_72;
8983                   break;
8984               }
8985             break;
8986           case 0xda:
8987               GETBYTE ();
8988               switch (op[2] & 0x00)
8989               {
8990                 case 0x00:
8991                   goto op_semantics_72;
8992                   break;
8993               }
8994             break;
8995           case 0xdb:
8996               GETBYTE ();
8997               switch (op[2] & 0x00)
8998               {
8999                 case 0x00:
9000                   goto op_semantics_72;
9001                   break;
9002               }
9003             break;
9004           case 0xe0:
9005               GETBYTE ();
9006               switch (op[2] & 0x0f)
9007               {
9008                 case 0x00:
9009                 case 0x01:
9010                 case 0x02:
9011                 case 0x03:
9012                 case 0x04:
9013                 case 0x05:
9014                 case 0x06:
9015                 case 0x07:
9016                 case 0x08:
9017                 case 0x09:
9018                 case 0x0a:
9019                 case 0x0b:
9020                 case 0x0c:
9021                 case 0x0d:
9022                 case 0x0e:
9023                   op_semantics_73:
9024                     {
9025                       /** 1111 1100 111bit sd rdst cond bm%2    #%1, %0%S0 */
9026 #line 983 "rx-decode.opc"
9027                       int bit AU = (op[1] >> 2) & 0x07;
9028 #line 983 "rx-decode.opc"
9029                       int sd AU = op[1] & 0x03;
9030 #line 983 "rx-decode.opc"
9031                       int rdst AU = (op[2] >> 4) & 0x0f;
9032 #line 983 "rx-decode.opc"
9033                       int cond AU = op[2] & 0x0f;
9034                       if (trace)
9035                         {
9036                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9037                                  "/** 1111 1100 111bit sd rdst cond     bm%2    #%1, %0%S0 */",
9038                                  op[0], op[1], op[2]);
9039                           printf ("  bit = 0x%x,", bit);
9040                           printf ("  sd = 0x%x,", sd);
9041                           printf ("  rdst = 0x%x,", rdst);
9042                           printf ("  cond = 0x%x\n", cond);
9043                         }
9044                       SYNTAX("bm%2      #%1, %0%S0");
9045 #line 983 "rx-decode.opc"
9046                       ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
9047
9048                     }
9049                   break;
9050                 case 0x0f:
9051                   op_semantics_74:
9052                     {
9053                       /** 1111 1100 111bit sd rdst 1111 bnot    #%1, %0%S0 */
9054 #line 971 "rx-decode.opc"
9055                       int bit AU = (op[1] >> 2) & 0x07;
9056 #line 971 "rx-decode.opc"
9057                       int sd AU = op[1] & 0x03;
9058 #line 971 "rx-decode.opc"
9059                       int rdst AU = (op[2] >> 4) & 0x0f;
9060                       if (trace)
9061                         {
9062                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9063                                  "/** 1111 1100 111bit sd rdst 1111     bnot    #%1, %0%S0 */",
9064                                  op[0], op[1], op[2]);
9065                           printf ("  bit = 0x%x,", bit);
9066                           printf ("  sd = 0x%x,", sd);
9067                           printf ("  rdst = 0x%x\n", rdst);
9068                         }
9069                       SYNTAX("bnot      #%1, %0%S0");
9070 #line 971 "rx-decode.opc"
9071                       ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
9072
9073                     }
9074                   break;
9075               }
9076             break;
9077           case 0xe1:
9078               GETBYTE ();
9079               switch (op[2] & 0x0f)
9080               {
9081                 case 0x00:
9082                 case 0x01:
9083                 case 0x02:
9084                 case 0x03:
9085                 case 0x04:
9086                 case 0x05:
9087                 case 0x06:
9088                 case 0x07:
9089                 case 0x08:
9090                 case 0x09:
9091                 case 0x0a:
9092                 case 0x0b:
9093                 case 0x0c:
9094                 case 0x0d:
9095                 case 0x0e:
9096                   goto op_semantics_73;
9097                   break;
9098                 case 0x0f:
9099                   goto op_semantics_74;
9100                   break;
9101               }
9102             break;
9103           case 0xe2:
9104               GETBYTE ();
9105               switch (op[2] & 0x0f)
9106               {
9107                 case 0x00:
9108                 case 0x01:
9109                 case 0x02:
9110                 case 0x03:
9111                 case 0x04:
9112                 case 0x05:
9113                 case 0x06:
9114                 case 0x07:
9115                 case 0x08:
9116                 case 0x09:
9117                 case 0x0a:
9118                 case 0x0b:
9119                 case 0x0c:
9120                 case 0x0d:
9121                 case 0x0e:
9122                   goto op_semantics_73;
9123                   break;
9124                 case 0x0f:
9125                   goto op_semantics_74;
9126                   break;
9127               }
9128             break;
9129           case 0xe3:
9130               GETBYTE ();
9131               switch (op[2] & 0x0f)
9132               {
9133                 case 0x00:
9134                 case 0x01:
9135                 case 0x02:
9136                 case 0x03:
9137                 case 0x04:
9138                 case 0x05:
9139                 case 0x06:
9140                 case 0x07:
9141                 case 0x08:
9142                 case 0x09:
9143                 case 0x0a:
9144                 case 0x0b:
9145                 case 0x0c:
9146                 case 0x0d:
9147                 case 0x0e:
9148                   goto op_semantics_73;
9149                   break;
9150                 case 0x0f:
9151                   goto op_semantics_74;
9152                   break;
9153               }
9154             break;
9155           case 0xe4:
9156               GETBYTE ();
9157               switch (op[2] & 0x0f)
9158               {
9159                 case 0x00:
9160                 case 0x01:
9161                 case 0x02:
9162                 case 0x03:
9163                 case 0x04:
9164                 case 0x05:
9165                 case 0x06:
9166                 case 0x07:
9167                 case 0x08:
9168                 case 0x09:
9169                 case 0x0a:
9170                 case 0x0b:
9171                 case 0x0c:
9172                 case 0x0d:
9173                 case 0x0e:
9174                   goto op_semantics_73;
9175                   break;
9176                 case 0x0f:
9177                   goto op_semantics_74;
9178                   break;
9179               }
9180             break;
9181           case 0xe5:
9182               GETBYTE ();
9183               switch (op[2] & 0x0f)
9184               {
9185                 case 0x00:
9186                 case 0x01:
9187                 case 0x02:
9188                 case 0x03:
9189                 case 0x04:
9190                 case 0x05:
9191                 case 0x06:
9192                 case 0x07:
9193                 case 0x08:
9194                 case 0x09:
9195                 case 0x0a:
9196                 case 0x0b:
9197                 case 0x0c:
9198                 case 0x0d:
9199                 case 0x0e:
9200                   goto op_semantics_73;
9201                   break;
9202                 case 0x0f:
9203                   goto op_semantics_74;
9204                   break;
9205               }
9206             break;
9207           case 0xe6:
9208               GETBYTE ();
9209               switch (op[2] & 0x0f)
9210               {
9211                 case 0x00:
9212                 case 0x01:
9213                 case 0x02:
9214                 case 0x03:
9215                 case 0x04:
9216                 case 0x05:
9217                 case 0x06:
9218                 case 0x07:
9219                 case 0x08:
9220                 case 0x09:
9221                 case 0x0a:
9222                 case 0x0b:
9223                 case 0x0c:
9224                 case 0x0d:
9225                 case 0x0e:
9226                   goto op_semantics_73;
9227                   break;
9228                 case 0x0f:
9229                   goto op_semantics_74;
9230                   break;
9231               }
9232             break;
9233           case 0xe7:
9234               GETBYTE ();
9235               switch (op[2] & 0x0f)
9236               {
9237                 case 0x00:
9238                 case 0x01:
9239                 case 0x02:
9240                 case 0x03:
9241                 case 0x04:
9242                 case 0x05:
9243                 case 0x06:
9244                 case 0x07:
9245                 case 0x08:
9246                 case 0x09:
9247                 case 0x0a:
9248                 case 0x0b:
9249                 case 0x0c:
9250                 case 0x0d:
9251                 case 0x0e:
9252                   goto op_semantics_73;
9253                   break;
9254                 case 0x0f:
9255                   goto op_semantics_74;
9256                   break;
9257               }
9258             break;
9259           case 0xe8:
9260               GETBYTE ();
9261               switch (op[2] & 0x0f)
9262               {
9263                 case 0x00:
9264                 case 0x01:
9265                 case 0x02:
9266                 case 0x03:
9267                 case 0x04:
9268                 case 0x05:
9269                 case 0x06:
9270                 case 0x07:
9271                 case 0x08:
9272                 case 0x09:
9273                 case 0x0a:
9274                 case 0x0b:
9275                 case 0x0c:
9276                 case 0x0d:
9277                 case 0x0e:
9278                   goto op_semantics_73;
9279                   break;
9280                 case 0x0f:
9281                   goto op_semantics_74;
9282                   break;
9283               }
9284             break;
9285           case 0xe9:
9286               GETBYTE ();
9287               switch (op[2] & 0x0f)
9288               {
9289                 case 0x00:
9290                 case 0x01:
9291                 case 0x02:
9292                 case 0x03:
9293                 case 0x04:
9294                 case 0x05:
9295                 case 0x06:
9296                 case 0x07:
9297                 case 0x08:
9298                 case 0x09:
9299                 case 0x0a:
9300                 case 0x0b:
9301                 case 0x0c:
9302                 case 0x0d:
9303                 case 0x0e:
9304                   goto op_semantics_73;
9305                   break;
9306                 case 0x0f:
9307                   goto op_semantics_74;
9308                   break;
9309               }
9310             break;
9311           case 0xea:
9312               GETBYTE ();
9313               switch (op[2] & 0x0f)
9314               {
9315                 case 0x00:
9316                 case 0x01:
9317                 case 0x02:
9318                 case 0x03:
9319                 case 0x04:
9320                 case 0x05:
9321                 case 0x06:
9322                 case 0x07:
9323                 case 0x08:
9324                 case 0x09:
9325                 case 0x0a:
9326                 case 0x0b:
9327                 case 0x0c:
9328                 case 0x0d:
9329                 case 0x0e:
9330                   goto op_semantics_73;
9331                   break;
9332                 case 0x0f:
9333                   goto op_semantics_74;
9334                   break;
9335               }
9336             break;
9337           case 0xeb:
9338               GETBYTE ();
9339               switch (op[2] & 0x0f)
9340               {
9341                 case 0x00:
9342                 case 0x01:
9343                 case 0x02:
9344                 case 0x03:
9345                 case 0x04:
9346                 case 0x05:
9347                 case 0x06:
9348                 case 0x07:
9349                 case 0x08:
9350                 case 0x09:
9351                 case 0x0a:
9352                 case 0x0b:
9353                 case 0x0c:
9354                 case 0x0d:
9355                 case 0x0e:
9356                   goto op_semantics_73;
9357                   break;
9358                 case 0x0f:
9359                   goto op_semantics_74;
9360                   break;
9361               }
9362             break;
9363           case 0xec:
9364               GETBYTE ();
9365               switch (op[2] & 0x0f)
9366               {
9367                 case 0x00:
9368                 case 0x01:
9369                 case 0x02:
9370                 case 0x03:
9371                 case 0x04:
9372                 case 0x05:
9373                 case 0x06:
9374                 case 0x07:
9375                 case 0x08:
9376                 case 0x09:
9377                 case 0x0a:
9378                 case 0x0b:
9379                 case 0x0c:
9380                 case 0x0d:
9381                 case 0x0e:
9382                   goto op_semantics_73;
9383                   break;
9384                 case 0x0f:
9385                   goto op_semantics_74;
9386                   break;
9387               }
9388             break;
9389           case 0xed:
9390               GETBYTE ();
9391               switch (op[2] & 0x0f)
9392               {
9393                 case 0x00:
9394                 case 0x01:
9395                 case 0x02:
9396                 case 0x03:
9397                 case 0x04:
9398                 case 0x05:
9399                 case 0x06:
9400                 case 0x07:
9401                 case 0x08:
9402                 case 0x09:
9403                 case 0x0a:
9404                 case 0x0b:
9405                 case 0x0c:
9406                 case 0x0d:
9407                 case 0x0e:
9408                   goto op_semantics_73;
9409                   break;
9410                 case 0x0f:
9411                   goto op_semantics_74;
9412                   break;
9413               }
9414             break;
9415           case 0xee:
9416               GETBYTE ();
9417               switch (op[2] & 0x0f)
9418               {
9419                 case 0x00:
9420                 case 0x01:
9421                 case 0x02:
9422                 case 0x03:
9423                 case 0x04:
9424                 case 0x05:
9425                 case 0x06:
9426                 case 0x07:
9427                 case 0x08:
9428                 case 0x09:
9429                 case 0x0a:
9430                 case 0x0b:
9431                 case 0x0c:
9432                 case 0x0d:
9433                 case 0x0e:
9434                   goto op_semantics_73;
9435                   break;
9436                 case 0x0f:
9437                   goto op_semantics_74;
9438                   break;
9439               }
9440             break;
9441           case 0xef:
9442               GETBYTE ();
9443               switch (op[2] & 0x0f)
9444               {
9445                 case 0x00:
9446                 case 0x01:
9447                 case 0x02:
9448                 case 0x03:
9449                 case 0x04:
9450                 case 0x05:
9451                 case 0x06:
9452                 case 0x07:
9453                 case 0x08:
9454                 case 0x09:
9455                 case 0x0a:
9456                 case 0x0b:
9457                 case 0x0c:
9458                 case 0x0d:
9459                 case 0x0e:
9460                   goto op_semantics_73;
9461                   break;
9462                 case 0x0f:
9463                   goto op_semantics_74;
9464                   break;
9465               }
9466             break;
9467           case 0xf0:
9468               GETBYTE ();
9469               switch (op[2] & 0x0f)
9470               {
9471                 case 0x00:
9472                 case 0x01:
9473                 case 0x02:
9474                 case 0x03:
9475                 case 0x04:
9476                 case 0x05:
9477                 case 0x06:
9478                 case 0x07:
9479                 case 0x08:
9480                 case 0x09:
9481                 case 0x0a:
9482                 case 0x0b:
9483                 case 0x0c:
9484                 case 0x0d:
9485                 case 0x0e:
9486                   goto op_semantics_73;
9487                   break;
9488                 case 0x0f:
9489                   goto op_semantics_74;
9490                   break;
9491               }
9492             break;
9493           case 0xf1:
9494               GETBYTE ();
9495               switch (op[2] & 0x0f)
9496               {
9497                 case 0x00:
9498                 case 0x01:
9499                 case 0x02:
9500                 case 0x03:
9501                 case 0x04:
9502                 case 0x05:
9503                 case 0x06:
9504                 case 0x07:
9505                 case 0x08:
9506                 case 0x09:
9507                 case 0x0a:
9508                 case 0x0b:
9509                 case 0x0c:
9510                 case 0x0d:
9511                 case 0x0e:
9512                   goto op_semantics_73;
9513                   break;
9514                 case 0x0f:
9515                   goto op_semantics_74;
9516                   break;
9517               }
9518             break;
9519           case 0xf2:
9520               GETBYTE ();
9521               switch (op[2] & 0x0f)
9522               {
9523                 case 0x00:
9524                 case 0x01:
9525                 case 0x02:
9526                 case 0x03:
9527                 case 0x04:
9528                 case 0x05:
9529                 case 0x06:
9530                 case 0x07:
9531                 case 0x08:
9532                 case 0x09:
9533                 case 0x0a:
9534                 case 0x0b:
9535                 case 0x0c:
9536                 case 0x0d:
9537                 case 0x0e:
9538                   goto op_semantics_73;
9539                   break;
9540                 case 0x0f:
9541                   goto op_semantics_74;
9542                   break;
9543               }
9544             break;
9545           case 0xf3:
9546               GETBYTE ();
9547               switch (op[2] & 0x0f)
9548               {
9549                 case 0x00:
9550                 case 0x01:
9551                 case 0x02:
9552                 case 0x03:
9553                 case 0x04:
9554                 case 0x05:
9555                 case 0x06:
9556                 case 0x07:
9557                 case 0x08:
9558                 case 0x09:
9559                 case 0x0a:
9560                 case 0x0b:
9561                 case 0x0c:
9562                 case 0x0d:
9563                 case 0x0e:
9564                   goto op_semantics_73;
9565                   break;
9566                 case 0x0f:
9567                   goto op_semantics_74;
9568                   break;
9569               }
9570             break;
9571           case 0xf4:
9572               GETBYTE ();
9573               switch (op[2] & 0x0f)
9574               {
9575                 case 0x00:
9576                 case 0x01:
9577                 case 0x02:
9578                 case 0x03:
9579                 case 0x04:
9580                 case 0x05:
9581                 case 0x06:
9582                 case 0x07:
9583                 case 0x08:
9584                 case 0x09:
9585                 case 0x0a:
9586                 case 0x0b:
9587                 case 0x0c:
9588                 case 0x0d:
9589                 case 0x0e:
9590                   goto op_semantics_73;
9591                   break;
9592                 case 0x0f:
9593                   goto op_semantics_74;
9594                   break;
9595               }
9596             break;
9597           case 0xf5:
9598               GETBYTE ();
9599               switch (op[2] & 0x0f)
9600               {
9601                 case 0x00:
9602                 case 0x01:
9603                 case 0x02:
9604                 case 0x03:
9605                 case 0x04:
9606                 case 0x05:
9607                 case 0x06:
9608                 case 0x07:
9609                 case 0x08:
9610                 case 0x09:
9611                 case 0x0a:
9612                 case 0x0b:
9613                 case 0x0c:
9614                 case 0x0d:
9615                 case 0x0e:
9616                   goto op_semantics_73;
9617                   break;
9618                 case 0x0f:
9619                   goto op_semantics_74;
9620                   break;
9621               }
9622             break;
9623           case 0xf6:
9624               GETBYTE ();
9625               switch (op[2] & 0x0f)
9626               {
9627                 case 0x00:
9628                 case 0x01:
9629                 case 0x02:
9630                 case 0x03:
9631                 case 0x04:
9632                 case 0x05:
9633                 case 0x06:
9634                 case 0x07:
9635                 case 0x08:
9636                 case 0x09:
9637                 case 0x0a:
9638                 case 0x0b:
9639                 case 0x0c:
9640                 case 0x0d:
9641                 case 0x0e:
9642                   goto op_semantics_73;
9643                   break;
9644                 case 0x0f:
9645                   goto op_semantics_74;
9646                   break;
9647               }
9648             break;
9649           case 0xf7:
9650               GETBYTE ();
9651               switch (op[2] & 0x0f)
9652               {
9653                 case 0x00:
9654                 case 0x01:
9655                 case 0x02:
9656                 case 0x03:
9657                 case 0x04:
9658                 case 0x05:
9659                 case 0x06:
9660                 case 0x07:
9661                 case 0x08:
9662                 case 0x09:
9663                 case 0x0a:
9664                 case 0x0b:
9665                 case 0x0c:
9666                 case 0x0d:
9667                 case 0x0e:
9668                   goto op_semantics_73;
9669                   break;
9670                 case 0x0f:
9671                   goto op_semantics_74;
9672                   break;
9673               }
9674             break;
9675           case 0xf8:
9676               GETBYTE ();
9677               switch (op[2] & 0x0f)
9678               {
9679                 case 0x00:
9680                 case 0x01:
9681                 case 0x02:
9682                 case 0x03:
9683                 case 0x04:
9684                 case 0x05:
9685                 case 0x06:
9686                 case 0x07:
9687                 case 0x08:
9688                 case 0x09:
9689                 case 0x0a:
9690                 case 0x0b:
9691                 case 0x0c:
9692                 case 0x0d:
9693                 case 0x0e:
9694                   goto op_semantics_73;
9695                   break;
9696                 case 0x0f:
9697                   goto op_semantics_74;
9698                   break;
9699               }
9700             break;
9701           case 0xf9:
9702               GETBYTE ();
9703               switch (op[2] & 0x0f)
9704               {
9705                 case 0x00:
9706                 case 0x01:
9707                 case 0x02:
9708                 case 0x03:
9709                 case 0x04:
9710                 case 0x05:
9711                 case 0x06:
9712                 case 0x07:
9713                 case 0x08:
9714                 case 0x09:
9715                 case 0x0a:
9716                 case 0x0b:
9717                 case 0x0c:
9718                 case 0x0d:
9719                 case 0x0e:
9720                   goto op_semantics_73;
9721                   break;
9722                 case 0x0f:
9723                   goto op_semantics_74;
9724                   break;
9725               }
9726             break;
9727           case 0xfa:
9728               GETBYTE ();
9729               switch (op[2] & 0x0f)
9730               {
9731                 case 0x00:
9732                 case 0x01:
9733                 case 0x02:
9734                 case 0x03:
9735                 case 0x04:
9736                 case 0x05:
9737                 case 0x06:
9738                 case 0x07:
9739                 case 0x08:
9740                 case 0x09:
9741                 case 0x0a:
9742                 case 0x0b:
9743                 case 0x0c:
9744                 case 0x0d:
9745                 case 0x0e:
9746                   goto op_semantics_73;
9747                   break;
9748                 case 0x0f:
9749                   goto op_semantics_74;
9750                   break;
9751               }
9752             break;
9753           case 0xfb:
9754               GETBYTE ();
9755               switch (op[2] & 0x0f)
9756               {
9757                 case 0x00:
9758                 case 0x01:
9759                 case 0x02:
9760                 case 0x03:
9761                 case 0x04:
9762                 case 0x05:
9763                 case 0x06:
9764                 case 0x07:
9765                 case 0x08:
9766                 case 0x09:
9767                 case 0x0a:
9768                 case 0x0b:
9769                 case 0x0c:
9770                 case 0x0d:
9771                 case 0x0e:
9772                   goto op_semantics_73;
9773                   break;
9774                 case 0x0f:
9775                   goto op_semantics_74;
9776                   break;
9777               }
9778             break;
9779           case 0xfc:
9780               GETBYTE ();
9781               switch (op[2] & 0x0f)
9782               {
9783                 case 0x00:
9784                 case 0x01:
9785                 case 0x02:
9786                 case 0x03:
9787                 case 0x04:
9788                 case 0x05:
9789                 case 0x06:
9790                 case 0x07:
9791                 case 0x08:
9792                 case 0x09:
9793                 case 0x0a:
9794                 case 0x0b:
9795                 case 0x0c:
9796                 case 0x0d:
9797                 case 0x0e:
9798                   goto op_semantics_73;
9799                   break;
9800                 case 0x0f:
9801                   goto op_semantics_74;
9802                   break;
9803               }
9804             break;
9805           case 0xfd:
9806               GETBYTE ();
9807               switch (op[2] & 0x0f)
9808               {
9809                 case 0x00:
9810                 case 0x01:
9811                 case 0x02:
9812                 case 0x03:
9813                 case 0x04:
9814                 case 0x05:
9815                 case 0x06:
9816                 case 0x07:
9817                 case 0x08:
9818                 case 0x09:
9819                 case 0x0a:
9820                 case 0x0b:
9821                 case 0x0c:
9822                 case 0x0d:
9823                 case 0x0e:
9824                   goto op_semantics_73;
9825                   break;
9826                 case 0x0f:
9827                   goto op_semantics_74;
9828                   break;
9829               }
9830             break;
9831           case 0xfe:
9832               GETBYTE ();
9833               switch (op[2] & 0x0f)
9834               {
9835                 case 0x00:
9836                 case 0x01:
9837                 case 0x02:
9838                 case 0x03:
9839                 case 0x04:
9840                 case 0x05:
9841                 case 0x06:
9842                 case 0x07:
9843                 case 0x08:
9844                 case 0x09:
9845                 case 0x0a:
9846                 case 0x0b:
9847                 case 0x0c:
9848                 case 0x0d:
9849                 case 0x0e:
9850                   goto op_semantics_73;
9851                   break;
9852                 case 0x0f:
9853                   goto op_semantics_74;
9854                   break;
9855               }
9856             break;
9857           case 0xff:
9858               GETBYTE ();
9859               switch (op[2] & 0x0f)
9860               {
9861                 case 0x00:
9862                 case 0x01:
9863                 case 0x02:
9864                 case 0x03:
9865                 case 0x04:
9866                 case 0x05:
9867                 case 0x06:
9868                 case 0x07:
9869                 case 0x08:
9870                 case 0x09:
9871                 case 0x0a:
9872                 case 0x0b:
9873                 case 0x0c:
9874                 case 0x0d:
9875                 case 0x0e:
9876                   goto op_semantics_73;
9877                   break;
9878                 case 0x0f:
9879                   goto op_semantics_74;
9880                   break;
9881               }
9882             break;
9883           default: UNSUPPORTED(); break;
9884         }
9885       break;
9886     case 0xfd:
9887         GETBYTE ();
9888         switch (op[1] & 0xff)
9889         {
9890           case 0x00:
9891               GETBYTE ();
9892               switch (op[2] & 0x00)
9893               {
9894                 case 0x00:
9895                   op_semantics_75:
9896                     {
9897                       /** 1111 1101 0000 a000 srca srcb mulhi   %1, %2, %0 */
9898 #line 848 "rx-decode.opc"
9899                       int a AU = (op[1] >> 3) & 0x01;
9900 #line 848 "rx-decode.opc"
9901                       int srca AU = (op[2] >> 4) & 0x0f;
9902 #line 848 "rx-decode.opc"
9903                       int srcb AU = op[2] & 0x0f;
9904                       if (trace)
9905                         {
9906                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9907                                  "/** 1111 1101 0000 a000 srca srcb     mulhi   %1, %2, %0 */",
9908                                  op[0], op[1], op[2]);
9909                           printf ("  a = 0x%x,", a);
9910                           printf ("  srca = 0x%x,", srca);
9911                           printf ("  srcb = 0x%x\n", srcb);
9912                         }
9913                       SYNTAX("mulhi     %1, %2, %0");
9914 #line 848 "rx-decode.opc"
9915                       ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
9916
9917                     }
9918                   break;
9919               }
9920             break;
9921           case 0x01:
9922               GETBYTE ();
9923               switch (op[2] & 0x00)
9924               {
9925                 case 0x00:
9926                   op_semantics_76:
9927                     {
9928                       /** 1111 1101 0000 a001 srca srcb mullo   %1, %2, %0 */
9929 #line 851 "rx-decode.opc"
9930                       int a AU = (op[1] >> 3) & 0x01;
9931 #line 851 "rx-decode.opc"
9932                       int srca AU = (op[2] >> 4) & 0x0f;
9933 #line 851 "rx-decode.opc"
9934                       int srcb AU = op[2] & 0x0f;
9935                       if (trace)
9936                         {
9937                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9938                                  "/** 1111 1101 0000 a001 srca srcb     mullo   %1, %2, %0 */",
9939                                  op[0], op[1], op[2]);
9940                           printf ("  a = 0x%x,", a);
9941                           printf ("  srca = 0x%x,", srca);
9942                           printf ("  srcb = 0x%x\n", srcb);
9943                         }
9944                       SYNTAX("mullo     %1, %2, %0");
9945 #line 851 "rx-decode.opc"
9946                       ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
9947
9948                     }
9949                   break;
9950               }
9951             break;
9952           case 0x02:
9953               GETBYTE ();
9954               switch (op[2] & 0x00)
9955               {
9956                 case 0x00:
9957                   op_semantics_77:
9958                     {
9959                       /** 1111 1101 0000 a010 srca srcb mullh   %1, %2, %0 */
9960 #line 1079 "rx-decode.opc"
9961                       int a AU = (op[1] >> 3) & 0x01;
9962 #line 1079 "rx-decode.opc"
9963                       int srca AU = (op[2] >> 4) & 0x0f;
9964 #line 1079 "rx-decode.opc"
9965                       int srcb AU = op[2] & 0x0f;
9966                       if (trace)
9967                         {
9968                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9969                                  "/** 1111 1101 0000 a010 srca srcb     mullh   %1, %2, %0 */",
9970                                  op[0], op[1], op[2]);
9971                           printf ("  a = 0x%x,", a);
9972                           printf ("  srca = 0x%x,", srca);
9973                           printf ("  srcb = 0x%x\n", srcb);
9974                         }
9975                       SYNTAX("mullh     %1, %2, %0");
9976 #line 1079 "rx-decode.opc"
9977                       ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
9978
9979                     }
9980                   break;
9981               }
9982             break;
9983           case 0x03:
9984               GETBYTE ();
9985               switch (op[2] & 0x00)
9986               {
9987                 case 0x00:
9988                   op_semantics_78:
9989                     {
9990                       /** 1111 1101 0000 a011 srca srcb         emula   %1, %2, %0 */
9991 #line 1064 "rx-decode.opc"
9992                       int a AU = (op[1] >> 3) & 0x01;
9993 #line 1064 "rx-decode.opc"
9994                       int srca AU = (op[2] >> 4) & 0x0f;
9995 #line 1064 "rx-decode.opc"
9996                       int srcb AU = op[2] & 0x0f;
9997                       if (trace)
9998                         {
9999                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10000                                  "/** 1111 1101 0000 a011 srca srcb     emula   %1, %2, %0 */",
10001                                  op[0], op[1], op[2]);
10002                           printf ("  a = 0x%x,", a);
10003                           printf ("  srca = 0x%x,", srca);
10004                           printf ("  srcb = 0x%x\n", srcb);
10005                         }
10006                       SYNTAX("emula     %1, %2, %0");
10007 #line 1064 "rx-decode.opc"
10008                       ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
10009
10010                     }
10011                   break;
10012               }
10013             break;
10014           case 0x04:
10015               GETBYTE ();
10016               switch (op[2] & 0x00)
10017               {
10018                 case 0x00:
10019                   op_semantics_79:
10020                     {
10021                       /** 1111 1101 0000 a100 srca srcb machi   %1, %2, %0 */
10022 #line 854 "rx-decode.opc"
10023                       int a AU = (op[1] >> 3) & 0x01;
10024 #line 854 "rx-decode.opc"
10025                       int srca AU = (op[2] >> 4) & 0x0f;
10026 #line 854 "rx-decode.opc"
10027                       int srcb AU = op[2] & 0x0f;
10028                       if (trace)
10029                         {
10030                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10031                                  "/** 1111 1101 0000 a100 srca srcb     machi   %1, %2, %0 */",
10032                                  op[0], op[1], op[2]);
10033                           printf ("  a = 0x%x,", a);
10034                           printf ("  srca = 0x%x,", srca);
10035                           printf ("  srcb = 0x%x\n", srcb);
10036                         }
10037                       SYNTAX("machi     %1, %2, %0");
10038 #line 854 "rx-decode.opc"
10039                       ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
10040
10041                     }
10042                   break;
10043               }
10044             break;
10045           case 0x05:
10046               GETBYTE ();
10047               switch (op[2] & 0x00)
10048               {
10049                 case 0x00:
10050                   op_semantics_80:
10051                     {
10052                       /** 1111 1101 0000 a101 srca srcb maclo   %1, %2, %0 */
10053 #line 857 "rx-decode.opc"
10054                       int a AU = (op[1] >> 3) & 0x01;
10055 #line 857 "rx-decode.opc"
10056                       int srca AU = (op[2] >> 4) & 0x0f;
10057 #line 857 "rx-decode.opc"
10058                       int srcb AU = op[2] & 0x0f;
10059                       if (trace)
10060                         {
10061                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10062                                  "/** 1111 1101 0000 a101 srca srcb     maclo   %1, %2, %0 */",
10063                                  op[0], op[1], op[2]);
10064                           printf ("  a = 0x%x,", a);
10065                           printf ("  srca = 0x%x,", srca);
10066                           printf ("  srcb = 0x%x\n", srcb);
10067                         }
10068                       SYNTAX("maclo     %1, %2, %0");
10069 #line 857 "rx-decode.opc"
10070                       ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
10071
10072                     }
10073                   break;
10074               }
10075             break;
10076           case 0x06:
10077               GETBYTE ();
10078               switch (op[2] & 0x00)
10079               {
10080                 case 0x00:
10081                   op_semantics_81:
10082                     {
10083                       /** 1111 1101 0000 a110 srca srcb maclh   %1, %2, %0 */
10084 #line 1067 "rx-decode.opc"
10085                       int a AU = (op[1] >> 3) & 0x01;
10086 #line 1067 "rx-decode.opc"
10087                       int srca AU = (op[2] >> 4) & 0x0f;
10088 #line 1067 "rx-decode.opc"
10089                       int srcb AU = op[2] & 0x0f;
10090                       if (trace)
10091                         {
10092                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10093                                  "/** 1111 1101 0000 a110 srca srcb     maclh   %1, %2, %0 */",
10094                                  op[0], op[1], op[2]);
10095                           printf ("  a = 0x%x,", a);
10096                           printf ("  srca = 0x%x,", srca);
10097                           printf ("  srcb = 0x%x\n", srcb);
10098                         }
10099                       SYNTAX("maclh     %1, %2, %0");
10100 #line 1067 "rx-decode.opc"
10101                       ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
10102
10103                     }
10104                   break;
10105               }
10106             break;
10107           case 0x07:
10108               GETBYTE ();
10109               switch (op[2] & 0x00)
10110               {
10111                 case 0x00:
10112                   op_semantics_82:
10113                     {
10114                       /** 1111 1101 0000 a111 srca srcb         emaca   %1, %2, %0 */
10115 #line 1058 "rx-decode.opc"
10116                       int a AU = (op[1] >> 3) & 0x01;
10117 #line 1058 "rx-decode.opc"
10118                       int srca AU = (op[2] >> 4) & 0x0f;
10119 #line 1058 "rx-decode.opc"
10120                       int srcb AU = op[2] & 0x0f;
10121                       if (trace)
10122                         {
10123                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10124                                  "/** 1111 1101 0000 a111 srca srcb     emaca   %1, %2, %0 */",
10125                                  op[0], op[1], op[2]);
10126                           printf ("  a = 0x%x,", a);
10127                           printf ("  srca = 0x%x,", srca);
10128                           printf ("  srcb = 0x%x\n", srcb);
10129                         }
10130                       SYNTAX("emaca     %1, %2, %0");
10131 #line 1058 "rx-decode.opc"
10132                       ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
10133
10134                     }
10135                   break;
10136               }
10137             break;
10138           case 0x08:
10139               GETBYTE ();
10140               switch (op[2] & 0x00)
10141               {
10142                 case 0x00:
10143                   goto op_semantics_75;
10144                   break;
10145               }
10146             break;
10147           case 0x09:
10148               GETBYTE ();
10149               switch (op[2] & 0x00)
10150               {
10151                 case 0x00:
10152                   goto op_semantics_76;
10153                   break;
10154               }
10155             break;
10156           case 0x0a:
10157               GETBYTE ();
10158               switch (op[2] & 0x00)
10159               {
10160                 case 0x00:
10161                   goto op_semantics_77;
10162                   break;
10163               }
10164             break;
10165           case 0x0b:
10166               GETBYTE ();
10167               switch (op[2] & 0x00)
10168               {
10169                 case 0x00:
10170                   goto op_semantics_78;
10171                   break;
10172               }
10173             break;
10174           case 0x0c:
10175               GETBYTE ();
10176               switch (op[2] & 0x00)
10177               {
10178                 case 0x00:
10179                   goto op_semantics_79;
10180                   break;
10181               }
10182             break;
10183           case 0x0d:
10184               GETBYTE ();
10185               switch (op[2] & 0x00)
10186               {
10187                 case 0x00:
10188                   goto op_semantics_80;
10189                   break;
10190               }
10191             break;
10192           case 0x0e:
10193               GETBYTE ();
10194               switch (op[2] & 0x00)
10195               {
10196                 case 0x00:
10197                   goto op_semantics_81;
10198                   break;
10199               }
10200             break;
10201           case 0x0f:
10202               GETBYTE ();
10203               switch (op[2] & 0x00)
10204               {
10205                 case 0x00:
10206                   goto op_semantics_82;
10207                   break;
10208               }
10209             break;
10210           case 0x17:
10211               GETBYTE ();
10212               switch (op[2] & 0x70)
10213               {
10214                 case 0x00:
10215                     {
10216                       /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
10217 #line 860 "rx-decode.opc"
10218                       int a AU = (op[2] >> 7) & 0x01;
10219 #line 860 "rx-decode.opc"
10220                       int rsrc AU = op[2] & 0x0f;
10221                       if (trace)
10222                         {
10223                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10224                                  "/** 1111 1101 0001 0111 a000 rsrc     mvtachi %1, %0 */",
10225                                  op[0], op[1], op[2]);
10226                           printf ("  a = 0x%x,", a);
10227                           printf ("  rsrc = 0x%x\n", rsrc);
10228                         }
10229                       SYNTAX("mvtachi   %1, %0");
10230 #line 860 "rx-decode.opc"
10231                       ID(mvtachi); DR(a+32); SR(rsrc); F_____;
10232
10233                     }
10234                   break;
10235                 case 0x10:
10236                     {
10237                       /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
10238 #line 863 "rx-decode.opc"
10239                       int a AU = (op[2] >> 7) & 0x01;
10240 #line 863 "rx-decode.opc"
10241                       int rsrc AU = op[2] & 0x0f;
10242                       if (trace)
10243                         {
10244                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10245                                  "/** 1111 1101 0001 0111 a001 rsrc     mvtaclo %1, %0 */",
10246                                  op[0], op[1], op[2]);
10247                           printf ("  a = 0x%x,", a);
10248                           printf ("  rsrc = 0x%x\n", rsrc);
10249                         }
10250                       SYNTAX("mvtaclo   %1, %0");
10251 #line 863 "rx-decode.opc"
10252                       ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
10253
10254                     }
10255                   break;
10256                 case 0x30:
10257                     {
10258                       /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */
10259 #line 1085 "rx-decode.opc"
10260                       int a AU = (op[2] >> 7) & 0x01;
10261 #line 1085 "rx-decode.opc"
10262                       int rdst AU = op[2] & 0x0f;
10263                       if (trace)
10264                         {
10265                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10266                                  "/** 1111 1101 0001 0111 a011 rdst     mvtacgu %0, %1 */",
10267                                  op[0], op[1], op[2]);
10268                           printf ("  a = 0x%x,", a);
10269                           printf ("  rdst = 0x%x\n", rdst);
10270                         }
10271                       SYNTAX("mvtacgu   %0, %1");
10272 #line 1085 "rx-decode.opc"
10273                       ID(mvtacgu); DR(a+32); SR(rdst); F_____;
10274
10275                     }
10276                   break;
10277                 default: UNSUPPORTED(); break;
10278               }
10279             break;
10280           case 0x18:
10281               GETBYTE ();
10282               switch (op[2] & 0x6f)
10283               {
10284                 case 0x00:
10285                     {
10286                       /** 1111 1101 0001 1000 a00i 0000 racw    #%1, %0 */
10287 #line 875 "rx-decode.opc"
10288                       int a AU = (op[2] >> 7) & 0x01;
10289 #line 875 "rx-decode.opc"
10290                       int i AU = (op[2] >> 4) & 0x01;
10291                       if (trace)
10292                         {
10293                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10294                                  "/** 1111 1101 0001 1000 a00i 0000     racw    #%1, %0 */",
10295                                  op[0], op[1], op[2]);
10296                           printf ("  a = 0x%x,", a);
10297                           printf ("  i = 0x%x\n", i);
10298                         }
10299                       SYNTAX("racw      #%1, %0");
10300 #line 875 "rx-decode.opc"
10301                       ID(racw); SC(i+1); DR(a+32); F_____;
10302
10303                     /*----------------------------------------------------------------------*/
10304                     /* SAT                                                                      */
10305
10306                     }
10307                   break;
10308                 case 0x40:
10309                     {
10310                       /** 1111 1101 0001 1000 a10i 0000 rdacw   #%1, %0 */
10311 #line 1094 "rx-decode.opc"
10312                       int a AU = (op[2] >> 7) & 0x01;
10313 #line 1094 "rx-decode.opc"
10314                       int i AU = (op[2] >> 4) & 0x01;
10315                       if (trace)
10316                         {
10317                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10318                                  "/** 1111 1101 0001 1000 a10i 0000     rdacw   #%1, %0 */",
10319                                  op[0], op[1], op[2]);
10320                           printf ("  a = 0x%x,", a);
10321                           printf ("  i = 0x%x\n", i);
10322                         }
10323                       SYNTAX("rdacw     #%1, %0");
10324 #line 1094 "rx-decode.opc"
10325                       ID(rdacw); SC(i+1); DR(a+32); F_____;
10326
10327                     }
10328                   break;
10329                 default: UNSUPPORTED(); break;
10330               }
10331             break;
10332           case 0x19:
10333               GETBYTE ();
10334               switch (op[2] & 0x6f)
10335               {
10336                 case 0x00:
10337                     {
10338                       /** 1111 1101 0001 1001 a00i 0000 racl    #%1, %0 */
10339 #line 1088 "rx-decode.opc"
10340                       int a AU = (op[2] >> 7) & 0x01;
10341 #line 1088 "rx-decode.opc"
10342                       int i AU = (op[2] >> 4) & 0x01;
10343                       if (trace)
10344                         {
10345                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10346                                  "/** 1111 1101 0001 1001 a00i 0000     racl    #%1, %0 */",
10347                                  op[0], op[1], op[2]);
10348                           printf ("  a = 0x%x,", a);
10349                           printf ("  i = 0x%x\n", i);
10350                         }
10351                       SYNTAX("racl      #%1, %0");
10352 #line 1088 "rx-decode.opc"
10353                       ID(racl); SC(i+1); DR(a+32); F_____;
10354
10355                     }
10356                   break;
10357                 case 0x40:
10358                     {
10359                       /** 1111 1101 0001 1001 a10i 0000 rdacl   #%1, %0 */
10360 #line 1091 "rx-decode.opc"
10361                       int a AU = (op[2] >> 7) & 0x01;
10362 #line 1091 "rx-decode.opc"
10363                       int i AU = (op[2] >> 4) & 0x01;
10364                       if (trace)
10365                         {
10366                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10367                                  "/** 1111 1101 0001 1001 a10i 0000     rdacl   #%1, %0 */",
10368                                  op[0], op[1], op[2]);
10369                           printf ("  a = 0x%x,", a);
10370                           printf ("  i = 0x%x\n", i);
10371                         }
10372                       SYNTAX("rdacl     #%1, %0");
10373 #line 1091 "rx-decode.opc"
10374                       ID(rdacl); SC(i+1); DR(a+32); F_____;
10375
10376                     }
10377                   break;
10378                 default: UNSUPPORTED(); break;
10379               }
10380             break;
10381           case 0x1e:
10382               GETBYTE ();
10383               switch (op[2] & 0x30)
10384               {
10385                 case 0x00:
10386                   op_semantics_83:
10387                     {
10388                       /** 1111 1101 0001 111i a m00 rdst        mvfachi #%2, %1, %0 */
10389 #line 866 "rx-decode.opc"
10390                       int i AU = op[1] & 0x01;
10391 #line 866 "rx-decode.opc"
10392                       int a AU = (op[2] >> 7) & 0x01;
10393 #line 866 "rx-decode.opc"
10394                       int m AU = (op[2] >> 6) & 0x01;
10395 #line 866 "rx-decode.opc"
10396                       int rdst AU = op[2] & 0x0f;
10397                       if (trace)
10398                         {
10399                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10400                                  "/** 1111 1101 0001 111i a m00 rdst    mvfachi #%2, %1, %0 */",
10401                                  op[0], op[1], op[2]);
10402                           printf ("  i = 0x%x,", i);
10403                           printf ("  a = 0x%x,", a);
10404                           printf ("  m = 0x%x,", m);
10405                           printf ("  rdst = 0x%x\n", rdst);
10406                         }
10407                       SYNTAX("mvfachi   #%2, %1, %0");
10408 #line 866 "rx-decode.opc"
10409                       ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10410
10411                     }
10412                   break;
10413                 case 0x10:
10414                   op_semantics_84:
10415                     {
10416                       /** 1111 1101 0001 111i a m01 rdst        mvfaclo #%2, %1, %0 */
10417 #line 872 "rx-decode.opc"
10418                       int i AU = op[1] & 0x01;
10419 #line 872 "rx-decode.opc"
10420                       int a AU = (op[2] >> 7) & 0x01;
10421 #line 872 "rx-decode.opc"
10422                       int m AU = (op[2] >> 6) & 0x01;
10423 #line 872 "rx-decode.opc"
10424                       int rdst AU = op[2] & 0x0f;
10425                       if (trace)
10426                         {
10427                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10428                                  "/** 1111 1101 0001 111i a m01 rdst    mvfaclo #%2, %1, %0 */",
10429                                  op[0], op[1], op[2]);
10430                           printf ("  i = 0x%x,", i);
10431                           printf ("  a = 0x%x,", a);
10432                           printf ("  m = 0x%x,", m);
10433                           printf ("  rdst = 0x%x\n", rdst);
10434                         }
10435                       SYNTAX("mvfaclo   #%2, %1, %0");
10436 #line 872 "rx-decode.opc"
10437                       ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10438
10439                     }
10440                   break;
10441                 case 0x20:
10442                   op_semantics_85:
10443                     {
10444                       /** 1111 1101 0001 111i a m10 rdst        mvfacmi #%2, %1, %0 */
10445 #line 869 "rx-decode.opc"
10446                       int i AU = op[1] & 0x01;
10447 #line 869 "rx-decode.opc"
10448                       int a AU = (op[2] >> 7) & 0x01;
10449 #line 869 "rx-decode.opc"
10450                       int m AU = (op[2] >> 6) & 0x01;
10451 #line 869 "rx-decode.opc"
10452                       int rdst AU = op[2] & 0x0f;
10453                       if (trace)
10454                         {
10455                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10456                                  "/** 1111 1101 0001 111i a m10 rdst    mvfacmi #%2, %1, %0 */",
10457                                  op[0], op[1], op[2]);
10458                           printf ("  i = 0x%x,", i);
10459                           printf ("  a = 0x%x,", a);
10460                           printf ("  m = 0x%x,", m);
10461                           printf ("  rdst = 0x%x\n", rdst);
10462                         }
10463                       SYNTAX("mvfacmi   #%2, %1, %0");
10464 #line 869 "rx-decode.opc"
10465                       ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10466
10467                     }
10468                   break;
10469                 case 0x30:
10470                   op_semantics_86:
10471                     {
10472                       /** 1111 1101 0001 111i a m11 rdst        mvfacgu #%2, %1, %0 */
10473 #line 1082 "rx-decode.opc"
10474                       int i AU = op[1] & 0x01;
10475 #line 1082 "rx-decode.opc"
10476                       int a AU = (op[2] >> 7) & 0x01;
10477 #line 1082 "rx-decode.opc"
10478                       int m AU = (op[2] >> 6) & 0x01;
10479 #line 1082 "rx-decode.opc"
10480                       int rdst AU = op[2] & 0x0f;
10481                       if (trace)
10482                         {
10483                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10484                                  "/** 1111 1101 0001 111i a m11 rdst    mvfacgu #%2, %1, %0 */",
10485                                  op[0], op[1], op[2]);
10486                           printf ("  i = 0x%x,", i);
10487                           printf ("  a = 0x%x,", a);
10488                           printf ("  m = 0x%x,", m);
10489                           printf ("  rdst = 0x%x\n", rdst);
10490                         }
10491                       SYNTAX("mvfacgu   #%2, %1, %0");
10492 #line 1082 "rx-decode.opc"
10493                       ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
10494
10495                     }
10496                   break;
10497               }
10498             break;
10499           case 0x1f:
10500               GETBYTE ();
10501               switch (op[2] & 0x30)
10502               {
10503                 case 0x00:
10504                   goto op_semantics_83;
10505                   break;
10506                 case 0x10:
10507                   goto op_semantics_84;
10508                   break;
10509                 case 0x20:
10510                   goto op_semantics_85;
10511                   break;
10512                 case 0x30:
10513                   goto op_semantics_86;
10514                   break;
10515               }
10516             break;
10517           case 0x20:
10518               GETBYTE ();
10519               switch (op[2] & 0x00)
10520               {
10521                 case 0x00:
10522                   op_semantics_87:
10523                     {
10524                       /** 1111 1101 0010 0p sz rdst rsrc        mov%s   %1, %0 */
10525 #line 344 "rx-decode.opc"
10526                       int p AU = (op[1] >> 2) & 0x01;
10527 #line 344 "rx-decode.opc"
10528                       int sz AU = op[1] & 0x03;
10529 #line 344 "rx-decode.opc"
10530                       int rdst AU = (op[2] >> 4) & 0x0f;
10531 #line 344 "rx-decode.opc"
10532                       int rsrc AU = op[2] & 0x0f;
10533                       if (trace)
10534                         {
10535                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10536                                  "/** 1111 1101 0010 0p sz rdst rsrc    mov%s   %1, %0 */",
10537                                  op[0], op[1], op[2]);
10538                           printf ("  p = 0x%x,", p);
10539                           printf ("  sz = 0x%x,", sz);
10540                           printf ("  rdst = 0x%x,", rdst);
10541                           printf ("  rsrc = 0x%x\n", rsrc);
10542                         }
10543                       SYNTAX("mov%s     %1, %0");
10544 #line 344 "rx-decode.opc"
10545                       ID(mov); sBWL (sz); SR(rsrc); F_____;
10546                       OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
10547
10548                     }
10549                   break;
10550               }
10551             break;
10552           case 0x21:
10553               GETBYTE ();
10554               switch (op[2] & 0x00)
10555               {
10556                 case 0x00:
10557                   goto op_semantics_87;
10558                   break;
10559               }
10560             break;
10561           case 0x22:
10562               GETBYTE ();
10563               switch (op[2] & 0x00)
10564               {
10565                 case 0x00:
10566                   goto op_semantics_87;
10567                   break;
10568               }
10569             break;
10570           case 0x24:
10571               GETBYTE ();
10572               switch (op[2] & 0x00)
10573               {
10574                 case 0x00:
10575                   goto op_semantics_87;
10576                   break;
10577               }
10578             break;
10579           case 0x25:
10580               GETBYTE ();
10581               switch (op[2] & 0x00)
10582               {
10583                 case 0x00:
10584                   goto op_semantics_87;
10585                   break;
10586               }
10587             break;
10588           case 0x26:
10589               GETBYTE ();
10590               switch (op[2] & 0x00)
10591               {
10592                 case 0x00:
10593                   goto op_semantics_87;
10594                   break;
10595               }
10596             break;
10597           case 0x27:
10598               GETBYTE ();
10599               switch (op[2] & 0x00)
10600               {
10601                 case 0x00:
10602                     {
10603                       /** 1111 1101 0010 0111 rdst rsrc movco   %1, [%0] */
10604 #line 1046 "rx-decode.opc"
10605                       int rdst AU = (op[2] >> 4) & 0x0f;
10606 #line 1046 "rx-decode.opc"
10607                       int rsrc AU = op[2] & 0x0f;
10608                       if (trace)
10609                         {
10610                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10611                                  "/** 1111 1101 0010 0111 rdst rsrc     movco   %1, [%0] */",
10612                                  op[0], op[1], op[2]);
10613                           printf ("  rdst = 0x%x,", rdst);
10614                           printf ("  rsrc = 0x%x\n", rsrc);
10615                         }
10616                       SYNTAX("movco     %1, [%0]");
10617 #line 1046 "rx-decode.opc"
10618                        ID(movco); SR(rsrc); DR(rdst); F_____;
10619
10620                     }
10621                   break;
10622               }
10623             break;
10624           case 0x28:
10625               GETBYTE ();
10626               switch (op[2] & 0x00)
10627               {
10628                 case 0x00:
10629                   op_semantics_88:
10630                     {
10631                       /** 1111 1101 0010 1p sz rsrc rdst        mov%s   %1, %0 */
10632 #line 348 "rx-decode.opc"
10633                       int p AU = (op[1] >> 2) & 0x01;
10634 #line 348 "rx-decode.opc"
10635                       int sz AU = op[1] & 0x03;
10636 #line 348 "rx-decode.opc"
10637                       int rsrc AU = (op[2] >> 4) & 0x0f;
10638 #line 348 "rx-decode.opc"
10639                       int rdst AU = op[2] & 0x0f;
10640                       if (trace)
10641                         {
10642                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10643                                  "/** 1111 1101 0010 1p sz rsrc rdst    mov%s   %1, %0 */",
10644                                  op[0], op[1], op[2]);
10645                           printf ("  p = 0x%x,", p);
10646                           printf ("  sz = 0x%x,", sz);
10647                           printf ("  rsrc = 0x%x,", rsrc);
10648                           printf ("  rdst = 0x%x\n", rdst);
10649                         }
10650                       SYNTAX("mov%s     %1, %0");
10651 #line 348 "rx-decode.opc"
10652                       ID(mov); sBWL (sz); DR(rdst); F_____;
10653                       OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10654
10655                     }
10656                   break;
10657               }
10658             break;
10659           case 0x29:
10660               GETBYTE ();
10661               switch (op[2] & 0x00)
10662               {
10663                 case 0x00:
10664                   goto op_semantics_88;
10665                   break;
10666               }
10667             break;
10668           case 0x2a:
10669               GETBYTE ();
10670               switch (op[2] & 0x00)
10671               {
10672                 case 0x00:
10673                   goto op_semantics_88;
10674                   break;
10675               }
10676             break;
10677           case 0x2c:
10678               GETBYTE ();
10679               switch (op[2] & 0x00)
10680               {
10681                 case 0x00:
10682                   goto op_semantics_88;
10683                   break;
10684               }
10685             break;
10686           case 0x2d:
10687               GETBYTE ();
10688               switch (op[2] & 0x00)
10689               {
10690                 case 0x00:
10691                   goto op_semantics_88;
10692                   break;
10693               }
10694             break;
10695           case 0x2e:
10696               GETBYTE ();
10697               switch (op[2] & 0x00)
10698               {
10699                 case 0x00:
10700                   goto op_semantics_88;
10701                   break;
10702               }
10703             break;
10704           case 0x2f:
10705               GETBYTE ();
10706               switch (op[2] & 0x00)
10707               {
10708                 case 0x00:
10709                     {
10710                       /** 1111 1101 0010 1111 rsrc rdst movli   [%1], %0 */
10711 #line 1049 "rx-decode.opc"
10712                       int rsrc AU = (op[2] >> 4) & 0x0f;
10713 #line 1049 "rx-decode.opc"
10714                       int rdst AU = op[2] & 0x0f;
10715                       if (trace)
10716                         {
10717                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10718                                  "/** 1111 1101 0010 1111 rsrc rdst     movli   [%1], %0 */",
10719                                  op[0], op[1], op[2]);
10720                           printf ("  rsrc = 0x%x,", rsrc);
10721                           printf ("  rdst = 0x%x\n", rdst);
10722                         }
10723                       SYNTAX("movli     [%1], %0");
10724 #line 1049 "rx-decode.opc"
10725                        ID(movli); SR(rsrc); DR(rdst); F_____;
10726
10727                     }
10728                   break;
10729               }
10730             break;
10731           case 0x38:
10732               GETBYTE ();
10733               switch (op[2] & 0x00)
10734               {
10735                 case 0x00:
10736                   op_semantics_89:
10737                     {
10738                       /** 1111 1101 0011 1p sz rsrc rdst        movu%s  %1, %0 */
10739 #line 358 "rx-decode.opc"
10740                       int p AU = (op[1] >> 2) & 0x01;
10741 #line 358 "rx-decode.opc"
10742                       int sz AU = op[1] & 0x03;
10743 #line 358 "rx-decode.opc"
10744                       int rsrc AU = (op[2] >> 4) & 0x0f;
10745 #line 358 "rx-decode.opc"
10746                       int rdst AU = op[2] & 0x0f;
10747                       if (trace)
10748                         {
10749                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10750                                  "/** 1111 1101 0011 1p sz rsrc rdst    movu%s  %1, %0 */",
10751                                  op[0], op[1], op[2]);
10752                           printf ("  p = 0x%x,", p);
10753                           printf ("  sz = 0x%x,", sz);
10754                           printf ("  rsrc = 0x%x,", rsrc);
10755                           printf ("  rdst = 0x%x\n", rdst);
10756                         }
10757                       SYNTAX("movu%s    %1, %0");
10758 #line 358 "rx-decode.opc"
10759                       ID(mov); uBW (sz); DR(rdst); F_____;
10760                        OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
10761
10762                     /*----------------------------------------------------------------------*/
10763                     /* PUSH/POP                                                         */
10764
10765                     }
10766                   break;
10767               }
10768             break;
10769           case 0x39:
10770               GETBYTE ();
10771               switch (op[2] & 0x00)
10772               {
10773                 case 0x00:
10774                   goto op_semantics_89;
10775                   break;
10776               }
10777             break;
10778           case 0x3a:
10779               GETBYTE ();
10780               switch (op[2] & 0x00)
10781               {
10782                 case 0x00:
10783                   goto op_semantics_89;
10784                   break;
10785               }
10786             break;
10787           case 0x3c:
10788               GETBYTE ();
10789               switch (op[2] & 0x00)
10790               {
10791                 case 0x00:
10792                   goto op_semantics_89;
10793                   break;
10794               }
10795             break;
10796           case 0x3d:
10797               GETBYTE ();
10798               switch (op[2] & 0x00)
10799               {
10800                 case 0x00:
10801                   goto op_semantics_89;
10802                   break;
10803               }
10804             break;
10805           case 0x3e:
10806               GETBYTE ();
10807               switch (op[2] & 0x00)
10808               {
10809                 case 0x00:
10810                   goto op_semantics_89;
10811                   break;
10812               }
10813             break;
10814           case 0x44:
10815               GETBYTE ();
10816               switch (op[2] & 0x00)
10817               {
10818                 case 0x00:
10819                   op_semantics_90:
10820                     {
10821                       /** 1111 1101 0100 a100 srca srcb msbhi   %1, %2, %0 */
10822 #line 1070 "rx-decode.opc"
10823                       int a AU = (op[1] >> 3) & 0x01;
10824 #line 1070 "rx-decode.opc"
10825                       int srca AU = (op[2] >> 4) & 0x0f;
10826 #line 1070 "rx-decode.opc"
10827                       int srcb AU = op[2] & 0x0f;
10828                       if (trace)
10829                         {
10830                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10831                                  "/** 1111 1101 0100 a100 srca srcb     msbhi   %1, %2, %0 */",
10832                                  op[0], op[1], op[2]);
10833                           printf ("  a = 0x%x,", a);
10834                           printf ("  srca = 0x%x,", srca);
10835                           printf ("  srcb = 0x%x\n", srcb);
10836                         }
10837                       SYNTAX("msbhi     %1, %2, %0");
10838 #line 1070 "rx-decode.opc"
10839                       ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
10840
10841                     }
10842                   break;
10843               }
10844             break;
10845           case 0x45:
10846               GETBYTE ();
10847               switch (op[2] & 0x00)
10848               {
10849                 case 0x00:
10850                   op_semantics_91:
10851                     {
10852                       /** 1111 1101 0100 a101 srca srcb msblo   %1, %2, %0 */
10853 #line 1076 "rx-decode.opc"
10854                       int a AU = (op[1] >> 3) & 0x01;
10855 #line 1076 "rx-decode.opc"
10856                       int srca AU = (op[2] >> 4) & 0x0f;
10857 #line 1076 "rx-decode.opc"
10858                       int srcb AU = op[2] & 0x0f;
10859                       if (trace)
10860                         {
10861                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10862                                  "/** 1111 1101 0100 a101 srca srcb     msblo   %1, %2, %0 */",
10863                                  op[0], op[1], op[2]);
10864                           printf ("  a = 0x%x,", a);
10865                           printf ("  srca = 0x%x,", srca);
10866                           printf ("  srcb = 0x%x\n", srcb);
10867                         }
10868                       SYNTAX("msblo     %1, %2, %0");
10869 #line 1076 "rx-decode.opc"
10870                       ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
10871
10872                     }
10873                   break;
10874               }
10875             break;
10876           case 0x46:
10877               GETBYTE ();
10878               switch (op[2] & 0x00)
10879               {
10880                 case 0x00:
10881                   op_semantics_92:
10882                     {
10883                       /** 1111 1101 0100 a110 srca srcb msblh   %1, %2, %0 */
10884 #line 1073 "rx-decode.opc"
10885                       int a AU = (op[1] >> 3) & 0x01;
10886 #line 1073 "rx-decode.opc"
10887                       int srca AU = (op[2] >> 4) & 0x0f;
10888 #line 1073 "rx-decode.opc"
10889                       int srcb AU = op[2] & 0x0f;
10890                       if (trace)
10891                         {
10892                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10893                                  "/** 1111 1101 0100 a110 srca srcb     msblh   %1, %2, %0 */",
10894                                  op[0], op[1], op[2]);
10895                           printf ("  a = 0x%x,", a);
10896                           printf ("  srca = 0x%x,", srca);
10897                           printf ("  srcb = 0x%x\n", srcb);
10898                         }
10899                       SYNTAX("msblh     %1, %2, %0");
10900 #line 1073 "rx-decode.opc"
10901                       ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
10902
10903                     }
10904                   break;
10905               }
10906             break;
10907           case 0x47:
10908               GETBYTE ();
10909               switch (op[2] & 0x00)
10910               {
10911                 case 0x00:
10912                   op_semantics_93:
10913                     {
10914                       /** 1111 1101 0100 a111 srca srcb         emsba   %1, %2, %0 */
10915 #line 1061 "rx-decode.opc"
10916                       int a AU = (op[1] >> 3) & 0x01;
10917 #line 1061 "rx-decode.opc"
10918                       int srca AU = (op[2] >> 4) & 0x0f;
10919 #line 1061 "rx-decode.opc"
10920                       int srcb AU = op[2] & 0x0f;
10921                       if (trace)
10922                         {
10923                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10924                                  "/** 1111 1101 0100 a111 srca srcb     emsba   %1, %2, %0 */",
10925                                  op[0], op[1], op[2]);
10926                           printf ("  a = 0x%x,", a);
10927                           printf ("  srca = 0x%x,", srca);
10928                           printf ("  srcb = 0x%x\n", srcb);
10929                         }
10930                       SYNTAX("emsba     %1, %2, %0");
10931 #line 1061 "rx-decode.opc"
10932                       ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
10933
10934                     }
10935                   break;
10936               }
10937             break;
10938           case 0x4c:
10939               GETBYTE ();
10940               switch (op[2] & 0x00)
10941               {
10942                 case 0x00:
10943                   goto op_semantics_90;
10944                   break;
10945               }
10946             break;
10947           case 0x4d:
10948               GETBYTE ();
10949               switch (op[2] & 0x00)
10950               {
10951                 case 0x00:
10952                   goto op_semantics_91;
10953                   break;
10954               }
10955             break;
10956           case 0x4e:
10957               GETBYTE ();
10958               switch (op[2] & 0x00)
10959               {
10960                 case 0x00:
10961                   goto op_semantics_92;
10962                   break;
10963               }
10964             break;
10965           case 0x4f:
10966               GETBYTE ();
10967               switch (op[2] & 0x00)
10968               {
10969                 case 0x00:
10970                   goto op_semantics_93;
10971                   break;
10972               }
10973             break;
10974           case 0x60:
10975               GETBYTE ();
10976               switch (op[2] & 0x00)
10977               {
10978                 case 0x00:
10979                     {
10980                       /** 1111 1101 0110 0000 rsrc rdst shlr    %2, %0 */
10981 #line 729 "rx-decode.opc"
10982                       int rsrc AU = (op[2] >> 4) & 0x0f;
10983 #line 729 "rx-decode.opc"
10984                       int rdst AU = op[2] & 0x0f;
10985                       if (trace)
10986                         {
10987                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10988                                  "/** 1111 1101 0110 0000 rsrc rdst     shlr    %2, %0 */",
10989                                  op[0], op[1], op[2]);
10990                           printf ("  rsrc = 0x%x,", rsrc);
10991                           printf ("  rdst = 0x%x\n", rdst);
10992                         }
10993                       SYNTAX("shlr      %2, %0");
10994 #line 729 "rx-decode.opc"
10995                       ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
10996
10997                     }
10998                   break;
10999               }
11000             break;
11001           case 0x61:
11002               GETBYTE ();
11003               switch (op[2] & 0x00)
11004               {
11005                 case 0x00:
11006                     {
11007                       /** 1111 1101 0110 0001 rsrc rdst shar    %2, %0 */
11008 #line 719 "rx-decode.opc"
11009                       int rsrc AU = (op[2] >> 4) & 0x0f;
11010 #line 719 "rx-decode.opc"
11011                       int rdst AU = op[2] & 0x0f;
11012                       if (trace)
11013                         {
11014                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11015                                  "/** 1111 1101 0110 0001 rsrc rdst     shar    %2, %0 */",
11016                                  op[0], op[1], op[2]);
11017                           printf ("  rsrc = 0x%x,", rsrc);
11018                           printf ("  rdst = 0x%x\n", rdst);
11019                         }
11020                       SYNTAX("shar      %2, %0");
11021 #line 719 "rx-decode.opc"
11022                       ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
11023
11024                     }
11025                   break;
11026               }
11027             break;
11028           case 0x62:
11029               GETBYTE ();
11030               switch (op[2] & 0x00)
11031               {
11032                 case 0x00:
11033                     {
11034                       /** 1111 1101 0110 0010 rsrc rdst shll    %2, %0 */
11035 #line 709 "rx-decode.opc"
11036                       int rsrc AU = (op[2] >> 4) & 0x0f;
11037 #line 709 "rx-decode.opc"
11038                       int rdst AU = op[2] & 0x0f;
11039                       if (trace)
11040                         {
11041                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11042                                  "/** 1111 1101 0110 0010 rsrc rdst     shll    %2, %0 */",
11043                                  op[0], op[1], op[2]);
11044                           printf ("  rsrc = 0x%x,", rsrc);
11045                           printf ("  rdst = 0x%x\n", rdst);
11046                         }
11047                       SYNTAX("shll      %2, %0");
11048 #line 709 "rx-decode.opc"
11049                       ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
11050
11051                     }
11052                   break;
11053               }
11054             break;
11055           case 0x64:
11056               GETBYTE ();
11057               switch (op[2] & 0x00)
11058               {
11059                 case 0x00:
11060                     {
11061                       /** 1111 1101 0110 0100 rsrc rdst rotr    %1, %0 */
11062 #line 753 "rx-decode.opc"
11063                       int rsrc AU = (op[2] >> 4) & 0x0f;
11064 #line 753 "rx-decode.opc"
11065                       int rdst AU = op[2] & 0x0f;
11066                       if (trace)
11067                         {
11068                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11069                                  "/** 1111 1101 0110 0100 rsrc rdst     rotr    %1, %0 */",
11070                                  op[0], op[1], op[2]);
11071                           printf ("  rsrc = 0x%x,", rsrc);
11072                           printf ("  rdst = 0x%x\n", rdst);
11073                         }
11074                       SYNTAX("rotr      %1, %0");
11075 #line 753 "rx-decode.opc"
11076                       ID(rotr); SR(rsrc); DR(rdst); F__SZC;
11077
11078                     }
11079                   break;
11080               }
11081             break;
11082           case 0x65:
11083               GETBYTE ();
11084               switch (op[2] & 0x00)
11085               {
11086                 case 0x00:
11087                     {
11088                       /** 1111 1101 0110 0101 rsrc rdst revw    %1, %0 */
11089 #line 756 "rx-decode.opc"
11090                       int rsrc AU = (op[2] >> 4) & 0x0f;
11091 #line 756 "rx-decode.opc"
11092                       int rdst AU = op[2] & 0x0f;
11093                       if (trace)
11094                         {
11095                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11096                                  "/** 1111 1101 0110 0101 rsrc rdst     revw    %1, %0 */",
11097                                  op[0], op[1], op[2]);
11098                           printf ("  rsrc = 0x%x,", rsrc);
11099                           printf ("  rdst = 0x%x\n", rdst);
11100                         }
11101                       SYNTAX("revw      %1, %0");
11102 #line 756 "rx-decode.opc"
11103                       ID(revw); SR(rsrc); DR(rdst);
11104
11105                     }
11106                   break;
11107               }
11108             break;
11109           case 0x66:
11110               GETBYTE ();
11111               switch (op[2] & 0x00)
11112               {
11113                 case 0x00:
11114                     {
11115                       /** 1111 1101 0110 0110 rsrc rdst rotl    %1, %0 */
11116 #line 747 "rx-decode.opc"
11117                       int rsrc AU = (op[2] >> 4) & 0x0f;
11118 #line 747 "rx-decode.opc"
11119                       int rdst AU = op[2] & 0x0f;
11120                       if (trace)
11121                         {
11122                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11123                                  "/** 1111 1101 0110 0110 rsrc rdst     rotl    %1, %0 */",
11124                                  op[0], op[1], op[2]);
11125                           printf ("  rsrc = 0x%x,", rsrc);
11126                           printf ("  rdst = 0x%x\n", rdst);
11127                         }
11128                       SYNTAX("rotl      %1, %0");
11129 #line 747 "rx-decode.opc"
11130                       ID(rotl); SR(rsrc); DR(rdst); F__SZC;
11131
11132                     }
11133                   break;
11134               }
11135             break;
11136           case 0x67:
11137               GETBYTE ();
11138               switch (op[2] & 0x00)
11139               {
11140                 case 0x00:
11141                     {
11142                       /** 1111 1101 0110 0111 rsrc rdst revl    %1, %0 */
11143 #line 759 "rx-decode.opc"
11144                       int rsrc AU = (op[2] >> 4) & 0x0f;
11145 #line 759 "rx-decode.opc"
11146                       int rdst AU = op[2] & 0x0f;
11147                       if (trace)
11148                         {
11149                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11150                                  "/** 1111 1101 0110 0111 rsrc rdst     revl    %1, %0 */",
11151                                  op[0], op[1], op[2]);
11152                           printf ("  rsrc = 0x%x,", rsrc);
11153                           printf ("  rdst = 0x%x\n", rdst);
11154                         }
11155                       SYNTAX("revl      %1, %0");
11156 #line 759 "rx-decode.opc"
11157                       ID(revl); SR(rsrc); DR(rdst);
11158
11159                     /*----------------------------------------------------------------------*/
11160                     /* BRANCH                                                           */
11161
11162                     }
11163                   break;
11164               }
11165             break;
11166           case 0x68:
11167               GETBYTE ();
11168               switch (op[2] & 0x00)
11169               {
11170                 case 0x00:
11171                   op_semantics_94:
11172                     {
11173                       /** 1111 1101 0110 100c rsrc rdst mvtc    %1, %0 */
11174 #line 1010 "rx-decode.opc"
11175                       int c AU = op[1] & 0x01;
11176 #line 1010 "rx-decode.opc"
11177                       int rsrc AU = (op[2] >> 4) & 0x0f;
11178 #line 1010 "rx-decode.opc"
11179                       int rdst AU = op[2] & 0x0f;
11180                       if (trace)
11181                         {
11182                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11183                                  "/** 1111 1101 0110 100c rsrc rdst     mvtc    %1, %0 */",
11184                                  op[0], op[1], op[2]);
11185                           printf ("  c = 0x%x,", c);
11186                           printf ("  rsrc = 0x%x,", rsrc);
11187                           printf ("  rdst = 0x%x\n", rdst);
11188                         }
11189                       SYNTAX("mvtc      %1, %0");
11190 #line 1010 "rx-decode.opc"
11191                       ID(mov); SR(rsrc); DR(c*16+rdst + 16);
11192
11193                     }
11194                   break;
11195               }
11196             break;
11197           case 0x69:
11198               GETBYTE ();
11199               switch (op[2] & 0x00)
11200               {
11201                 case 0x00:
11202                   goto op_semantics_94;
11203                   break;
11204               }
11205             break;
11206           case 0x6a:
11207               GETBYTE ();
11208               switch (op[2] & 0x00)
11209               {
11210                 case 0x00:
11211                   op_semantics_95:
11212                     {
11213                       /** 1111 1101 0110 101s rsrc rdst mvfc    %1, %0 */
11214 #line 1013 "rx-decode.opc"
11215                       int s AU = op[1] & 0x01;
11216 #line 1013 "rx-decode.opc"
11217                       int rsrc AU = (op[2] >> 4) & 0x0f;
11218 #line 1013 "rx-decode.opc"
11219                       int rdst AU = op[2] & 0x0f;
11220                       if (trace)
11221                         {
11222                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11223                                  "/** 1111 1101 0110 101s rsrc rdst     mvfc    %1, %0 */",
11224                                  op[0], op[1], op[2]);
11225                           printf ("  s = 0x%x,", s);
11226                           printf ("  rsrc = 0x%x,", rsrc);
11227                           printf ("  rdst = 0x%x\n", rdst);
11228                         }
11229                       SYNTAX("mvfc      %1, %0");
11230 #line 1013 "rx-decode.opc"
11231                       ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
11232
11233                     /*----------------------------------------------------------------------*/
11234                     /* INTERRUPTS                                                               */
11235
11236                     }
11237                   break;
11238               }
11239             break;
11240           case 0x6b:
11241               GETBYTE ();
11242               switch (op[2] & 0x00)
11243               {
11244                 case 0x00:
11245                   goto op_semantics_95;
11246                   break;
11247               }
11248             break;
11249           case 0x6c:
11250               GETBYTE ();
11251               switch (op[2] & 0x00)
11252               {
11253                 case 0x00:
11254                   op_semantics_96:
11255                     {
11256                       /** 1111 1101 0110 110i mmmm rdst rotr    #%1, %0 */
11257 #line 750 "rx-decode.opc"
11258                       int i AU = op[1] & 0x01;
11259 #line 750 "rx-decode.opc"
11260                       int mmmm AU = (op[2] >> 4) & 0x0f;
11261 #line 750 "rx-decode.opc"
11262                       int rdst AU = op[2] & 0x0f;
11263                       if (trace)
11264                         {
11265                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11266                                  "/** 1111 1101 0110 110i mmmm rdst     rotr    #%1, %0 */",
11267                                  op[0], op[1], op[2]);
11268                           printf ("  i = 0x%x,", i);
11269                           printf ("  mmmm = 0x%x,", mmmm);
11270                           printf ("  rdst = 0x%x\n", rdst);
11271                         }
11272                       SYNTAX("rotr      #%1, %0");
11273 #line 750 "rx-decode.opc"
11274                       ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
11275
11276                     }
11277                   break;
11278               }
11279             break;
11280           case 0x6d:
11281               GETBYTE ();
11282               switch (op[2] & 0x00)
11283               {
11284                 case 0x00:
11285                   goto op_semantics_96;
11286                   break;
11287               }
11288             break;
11289           case 0x6e:
11290               GETBYTE ();
11291               switch (op[2] & 0x00)
11292               {
11293                 case 0x00:
11294                   op_semantics_97:
11295                     {
11296                       /** 1111 1101 0110 111i mmmm rdst rotl    #%1, %0 */
11297 #line 744 "rx-decode.opc"
11298                       int i AU = op[1] & 0x01;
11299 #line 744 "rx-decode.opc"
11300                       int mmmm AU = (op[2] >> 4) & 0x0f;
11301 #line 744 "rx-decode.opc"
11302                       int rdst AU = op[2] & 0x0f;
11303                       if (trace)
11304                         {
11305                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11306                                  "/** 1111 1101 0110 111i mmmm rdst     rotl    #%1, %0 */",
11307                                  op[0], op[1], op[2]);
11308                           printf ("  i = 0x%x,", i);
11309                           printf ("  mmmm = 0x%x,", mmmm);
11310                           printf ("  rdst = 0x%x\n", rdst);
11311                         }
11312                       SYNTAX("rotl      #%1, %0");
11313 #line 744 "rx-decode.opc"
11314                       ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
11315
11316                     }
11317                   break;
11318               }
11319             break;
11320           case 0x6f:
11321               GETBYTE ();
11322               switch (op[2] & 0x00)
11323               {
11324                 case 0x00:
11325                   goto op_semantics_97;
11326                   break;
11327               }
11328             break;
11329           case 0x70:
11330               GETBYTE ();
11331               switch (op[2] & 0xf0)
11332               {
11333                 case 0x20:
11334                   op_semantics_98:
11335                     {
11336                       /** 1111 1101 0111 im00 0010rdst  adc     #%1, %0 */
11337 #line 488 "rx-decode.opc"
11338                       int im AU = (op[1] >> 2) & 0x03;
11339 #line 488 "rx-decode.opc"
11340                       int rdst AU = op[2] & 0x0f;
11341                       if (trace)
11342                         {
11343                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11344                                  "/** 1111 1101 0111 im00 0010rdst      adc     #%1, %0 */",
11345                                  op[0], op[1], op[2]);
11346                           printf ("  im = 0x%x,", im);
11347                           printf ("  rdst = 0x%x\n", rdst);
11348                         }
11349                       SYNTAX("adc       #%1, %0");
11350 #line 488 "rx-decode.opc"
11351                       ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
11352
11353                     }
11354                   break;
11355                 case 0x40:
11356                   op_semantics_99:
11357                     {
11358                       /** 1111 1101 0111 im00 0100rdst  max     #%1, %0 */
11359 #line 570 "rx-decode.opc"
11360                       int im AU = (op[1] >> 2) & 0x03;
11361 #line 570 "rx-decode.opc"
11362                       int rdst AU = op[2] & 0x0f;
11363                       if (trace)
11364                         {
11365                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11366                                  "/** 1111 1101 0111 im00 0100rdst      max     #%1, %0 */",
11367                                  op[0], op[1], op[2]);
11368                           printf ("  im = 0x%x,", im);
11369                           printf ("  rdst = 0x%x\n", rdst);
11370                         }
11371                       SYNTAX("max       #%1, %0");
11372 #line 570 "rx-decode.opc"
11373                       int val = IMMex (im);
11374                       if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
11375                         {
11376                           ID (nop7);
11377                           SYNTAX("nop\t; max\t#0x80000000, r0");
11378                         }
11379                       else
11380                         {
11381                           ID(max);
11382                         }
11383                       DR(rdst); SC(val);
11384
11385                     }
11386                   break;
11387                 case 0x50:
11388                   op_semantics_100:
11389                     {
11390                       /** 1111 1101 0111 im00 0101rdst  min     #%1, %0 */
11391 #line 600 "rx-decode.opc"
11392                       int im AU = (op[1] >> 2) & 0x03;
11393 #line 600 "rx-decode.opc"
11394                       int rdst AU = op[2] & 0x0f;
11395                       if (trace)
11396                         {
11397                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11398                                  "/** 1111 1101 0111 im00 0101rdst      min     #%1, %0 */",
11399                                  op[0], op[1], op[2]);
11400                           printf ("  im = 0x%x,", im);
11401                           printf ("  rdst = 0x%x\n", rdst);
11402                         }
11403                       SYNTAX("min       #%1, %0");
11404 #line 600 "rx-decode.opc"
11405                       ID(min); DR(rdst); SC(IMMex(im));
11406
11407                     }
11408                   break;
11409                 case 0x60:
11410                   op_semantics_101:
11411                     {
11412                       /** 1111 1101 0111 im00 0110rdst  emul    #%1, %0 */
11413 #line 658 "rx-decode.opc"
11414                       int im AU = (op[1] >> 2) & 0x03;
11415 #line 658 "rx-decode.opc"
11416                       int rdst AU = op[2] & 0x0f;
11417                       if (trace)
11418                         {
11419                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11420                                  "/** 1111 1101 0111 im00 0110rdst      emul    #%1, %0 */",
11421                                  op[0], op[1], op[2]);
11422                           printf ("  im = 0x%x,", im);
11423                           printf ("  rdst = 0x%x\n", rdst);
11424                         }
11425                       SYNTAX("emul      #%1, %0");
11426 #line 658 "rx-decode.opc"
11427                       ID(emul); DR(rdst); SC(IMMex(im));
11428
11429                     }
11430                   break;
11431                 case 0x70:
11432                   op_semantics_102:
11433                     {
11434                       /** 1111 1101 0111 im00 0111rdst  emulu   #%1, %0 */
11435 #line 670 "rx-decode.opc"
11436                       int im AU = (op[1] >> 2) & 0x03;
11437 #line 670 "rx-decode.opc"
11438                       int rdst AU = op[2] & 0x0f;
11439                       if (trace)
11440                         {
11441                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11442                                  "/** 1111 1101 0111 im00 0111rdst      emulu   #%1, %0 */",
11443                                  op[0], op[1], op[2]);
11444                           printf ("  im = 0x%x,", im);
11445                           printf ("  rdst = 0x%x\n", rdst);
11446                         }
11447                       SYNTAX("emulu     #%1, %0");
11448 #line 670 "rx-decode.opc"
11449                       ID(emulu); DR(rdst); SC(IMMex(im));
11450
11451                     }
11452                   break;
11453                 case 0x80:
11454                   op_semantics_103:
11455                     {
11456                       /** 1111 1101 0111 im00 1000rdst  div     #%1, %0 */
11457 #line 682 "rx-decode.opc"
11458                       int im AU = (op[1] >> 2) & 0x03;
11459 #line 682 "rx-decode.opc"
11460                       int rdst AU = op[2] & 0x0f;
11461                       if (trace)
11462                         {
11463                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11464                                  "/** 1111 1101 0111 im00 1000rdst      div     #%1, %0 */",
11465                                  op[0], op[1], op[2]);
11466                           printf ("  im = 0x%x,", im);
11467                           printf ("  rdst = 0x%x\n", rdst);
11468                         }
11469                       SYNTAX("div       #%1, %0");
11470 #line 682 "rx-decode.opc"
11471                       ID(div); DR(rdst); SC(IMMex(im)); F_O___;
11472
11473                     }
11474                   break;
11475                 case 0x90:
11476                   op_semantics_104:
11477                     {
11478                       /** 1111 1101 0111 im00 1001rdst  divu    #%1, %0 */
11479 #line 694 "rx-decode.opc"
11480                       int im AU = (op[1] >> 2) & 0x03;
11481 #line 694 "rx-decode.opc"
11482                       int rdst AU = op[2] & 0x0f;
11483                       if (trace)
11484                         {
11485                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11486                                  "/** 1111 1101 0111 im00 1001rdst      divu    #%1, %0 */",
11487                                  op[0], op[1], op[2]);
11488                           printf ("  im = 0x%x,", im);
11489                           printf ("  rdst = 0x%x\n", rdst);
11490                         }
11491                       SYNTAX("divu      #%1, %0");
11492 #line 694 "rx-decode.opc"
11493                       ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
11494
11495                     }
11496                   break;
11497                 case 0xc0:
11498                   op_semantics_105:
11499                     {
11500                       /** 1111 1101 0111 im00 1100rdst  tst     #%1, %2 */
11501 #line 467 "rx-decode.opc"
11502                       int im AU = (op[1] >> 2) & 0x03;
11503 #line 467 "rx-decode.opc"
11504                       int rdst AU = op[2] & 0x0f;
11505                       if (trace)
11506                         {
11507                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11508                                  "/** 1111 1101 0111 im00 1100rdst      tst     #%1, %2 */",
11509                                  op[0], op[1], op[2]);
11510                           printf ("  im = 0x%x,", im);
11511                           printf ("  rdst = 0x%x\n", rdst);
11512                         }
11513                       SYNTAX("tst       #%1, %2");
11514 #line 467 "rx-decode.opc"
11515                       ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
11516
11517                     }
11518                   break;
11519                 case 0xd0:
11520                   op_semantics_106:
11521                     {
11522                       /** 1111 1101 0111 im00 1101rdst  xor     #%1, %0 */
11523 #line 446 "rx-decode.opc"
11524                       int im AU = (op[1] >> 2) & 0x03;
11525 #line 446 "rx-decode.opc"
11526                       int rdst AU = op[2] & 0x0f;
11527                       if (trace)
11528                         {
11529                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11530                                  "/** 1111 1101 0111 im00 1101rdst      xor     #%1, %0 */",
11531                                  op[0], op[1], op[2]);
11532                           printf ("  im = 0x%x,", im);
11533                           printf ("  rdst = 0x%x\n", rdst);
11534                         }
11535                       SYNTAX("xor       #%1, %0");
11536 #line 446 "rx-decode.opc"
11537                       ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
11538
11539                     }
11540                   break;
11541                 case 0xe0:
11542                   op_semantics_107:
11543                     {
11544                       /** 1111 1101 0111 im00 1110rdst  stz     #%1, %0 */
11545 #line 392 "rx-decode.opc"
11546                       int im AU = (op[1] >> 2) & 0x03;
11547 #line 392 "rx-decode.opc"
11548                       int rdst AU = op[2] & 0x0f;
11549                       if (trace)
11550                         {
11551                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11552                                  "/** 1111 1101 0111 im00 1110rdst      stz     #%1, %0 */",
11553                                  op[0], op[1], op[2]);
11554                           printf ("  im = 0x%x,", im);
11555                           printf ("  rdst = 0x%x\n", rdst);
11556                         }
11557                       SYNTAX("stz       #%1, %0");
11558 #line 392 "rx-decode.opc"
11559                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
11560
11561                     }
11562                   break;
11563                 case 0xf0:
11564                   op_semantics_108:
11565                     {
11566                       /** 1111 1101 0111 im00 1111rdst  stnz    #%1, %0 */
11567 #line 395 "rx-decode.opc"
11568                       int im AU = (op[1] >> 2) & 0x03;
11569 #line 395 "rx-decode.opc"
11570                       int rdst AU = op[2] & 0x0f;
11571                       if (trace)
11572                         {
11573                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11574                                  "/** 1111 1101 0111 im00 1111rdst      stnz    #%1, %0 */",
11575                                  op[0], op[1], op[2]);
11576                           printf ("  im = 0x%x,", im);
11577                           printf ("  rdst = 0x%x\n", rdst);
11578                         }
11579                       SYNTAX("stnz      #%1, %0");
11580 #line 395 "rx-decode.opc"
11581                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
11582
11583                     /*----------------------------------------------------------------------*/
11584                     /* RTSD                                                                     */
11585
11586                     }
11587                   break;
11588                 default: UNSUPPORTED(); break;
11589               }
11590             break;
11591           case 0x72:
11592               GETBYTE ();
11593               switch (op[2] & 0xf0)
11594               {
11595                 case 0x00:
11596                     {
11597                       /** 1111 1101 0111 0010 0000 rdst fsub    #%1, %0 */
11598 #line 902 "rx-decode.opc"
11599                       int rdst AU = op[2] & 0x0f;
11600                       if (trace)
11601                         {
11602                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11603                                  "/** 1111 1101 0111 0010 0000 rdst     fsub    #%1, %0 */",
11604                                  op[0], op[1], op[2]);
11605                           printf ("  rdst = 0x%x\n", rdst);
11606                         }
11607                       SYNTAX("fsub      #%1, %0");
11608 #line 902 "rx-decode.opc"
11609                       ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
11610
11611                     }
11612                   break;
11613                 case 0x10:
11614                     {
11615                       /** 1111 1101 0111 0010 0001 rdst fcmp    #%1, %0 */
11616 #line 896 "rx-decode.opc"
11617                       int rdst AU = op[2] & 0x0f;
11618                       if (trace)
11619                         {
11620                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11621                                  "/** 1111 1101 0111 0010 0001 rdst     fcmp    #%1, %0 */",
11622                                  op[0], op[1], op[2]);
11623                           printf ("  rdst = 0x%x\n", rdst);
11624                         }
11625                       SYNTAX("fcmp      #%1, %0");
11626 #line 896 "rx-decode.opc"
11627                       ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
11628
11629                     }
11630                   break;
11631                 case 0x20:
11632                     {
11633                       /** 1111 1101 0111 0010 0010 rdst fadd    #%1, %0 */
11634 #line 890 "rx-decode.opc"
11635                       int rdst AU = op[2] & 0x0f;
11636                       if (trace)
11637                         {
11638                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11639                                  "/** 1111 1101 0111 0010 0010 rdst     fadd    #%1, %0 */",
11640                                  op[0], op[1], op[2]);
11641                           printf ("  rdst = 0x%x\n", rdst);
11642                         }
11643                       SYNTAX("fadd      #%1, %0");
11644 #line 890 "rx-decode.opc"
11645                       ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
11646
11647                     }
11648                   break;
11649                 case 0x30:
11650                     {
11651                       /** 1111 1101 0111 0010 0011 rdst fmul    #%1, %0 */
11652 #line 911 "rx-decode.opc"
11653                       int rdst AU = op[2] & 0x0f;
11654                       if (trace)
11655                         {
11656                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11657                                  "/** 1111 1101 0111 0010 0011 rdst     fmul    #%1, %0 */",
11658                                  op[0], op[1], op[2]);
11659                           printf ("  rdst = 0x%x\n", rdst);
11660                         }
11661                       SYNTAX("fmul      #%1, %0");
11662 #line 911 "rx-decode.opc"
11663                       ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
11664
11665                     }
11666                   break;
11667                 case 0x40:
11668                     {
11669                       /** 1111 1101 0111 0010 0100 rdst fdiv    #%1, %0 */
11670 #line 917 "rx-decode.opc"
11671                       int rdst AU = op[2] & 0x0f;
11672                       if (trace)
11673                         {
11674                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11675                                  "/** 1111 1101 0111 0010 0100 rdst     fdiv    #%1, %0 */",
11676                                  op[0], op[1], op[2]);
11677                           printf ("  rdst = 0x%x\n", rdst);
11678                         }
11679                       SYNTAX("fdiv      #%1, %0");
11680 #line 917 "rx-decode.opc"
11681                       ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
11682
11683                     }
11684                   break;
11685                 default: UNSUPPORTED(); break;
11686               }
11687             break;
11688           case 0x73:
11689               GETBYTE ();
11690               switch (op[2] & 0xe0)
11691               {
11692                 case 0x00:
11693                   op_semantics_109:
11694                     {
11695                       /** 1111 1101 0111 im11 000crdst  mvtc    #%1, %0 */
11696 #line 1007 "rx-decode.opc"
11697                       int im AU = (op[1] >> 2) & 0x03;
11698 #line 1007 "rx-decode.opc"
11699                       int crdst AU = op[2] & 0x1f;
11700                       if (trace)
11701                         {
11702                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11703                                  "/** 1111 1101 0111 im11 000crdst      mvtc    #%1, %0 */",
11704                                  op[0], op[1], op[2]);
11705                           printf ("  im = 0x%x,", im);
11706                           printf ("  crdst = 0x%x\n", crdst);
11707                         }
11708                       SYNTAX("mvtc      #%1, %0");
11709 #line 1007 "rx-decode.opc"
11710                       ID(mov); SC(IMMex(im)); DR(crdst + 16);
11711
11712                     }
11713                   break;
11714                 default: UNSUPPORTED(); break;
11715               }
11716             break;
11717           case 0x74:
11718               GETBYTE ();
11719               switch (op[2] & 0xf0)
11720               {
11721                 case 0x20:
11722                   goto op_semantics_98;
11723                   break;
11724                 case 0x40:
11725                   goto op_semantics_99;
11726                   break;
11727                 case 0x50:
11728                   goto op_semantics_100;
11729                   break;
11730                 case 0x60:
11731                   goto op_semantics_101;
11732                   break;
11733                 case 0x70:
11734                   goto op_semantics_102;
11735                   break;
11736                 case 0x80:
11737                   goto op_semantics_103;
11738                   break;
11739                 case 0x90:
11740                   goto op_semantics_104;
11741                   break;
11742                 case 0xc0:
11743                   goto op_semantics_105;
11744                   break;
11745                 case 0xd0:
11746                   goto op_semantics_106;
11747                   break;
11748                 case 0xe0:
11749                   goto op_semantics_107;
11750                   break;
11751                 case 0xf0:
11752                   goto op_semantics_108;
11753                   break;
11754                 default: UNSUPPORTED(); break;
11755               }
11756             break;
11757           case 0x77:
11758               GETBYTE ();
11759               switch (op[2] & 0xe0)
11760               {
11761                 case 0x00:
11762                   goto op_semantics_109;
11763                   break;
11764                 default: UNSUPPORTED(); break;
11765               }
11766             break;
11767           case 0x78:
11768               GETBYTE ();
11769               switch (op[2] & 0xf0)
11770               {
11771                 case 0x20:
11772                   goto op_semantics_98;
11773                   break;
11774                 case 0x40:
11775                   goto op_semantics_99;
11776                   break;
11777                 case 0x50:
11778                   goto op_semantics_100;
11779                   break;
11780                 case 0x60:
11781                   goto op_semantics_101;
11782                   break;
11783                 case 0x70:
11784                   goto op_semantics_102;
11785                   break;
11786                 case 0x80:
11787                   goto op_semantics_103;
11788                   break;
11789                 case 0x90:
11790                   goto op_semantics_104;
11791                   break;
11792                 case 0xc0:
11793                   goto op_semantics_105;
11794                   break;
11795                 case 0xd0:
11796                   goto op_semantics_106;
11797                   break;
11798                 case 0xe0:
11799                   goto op_semantics_107;
11800                   break;
11801                 case 0xf0:
11802                   goto op_semantics_108;
11803                   break;
11804                 default: UNSUPPORTED(); break;
11805               }
11806             break;
11807           case 0x7b:
11808               GETBYTE ();
11809               switch (op[2] & 0xe0)
11810               {
11811                 case 0x00:
11812                   goto op_semantics_109;
11813                   break;
11814                 default: UNSUPPORTED(); break;
11815               }
11816             break;
11817           case 0x7c:
11818               GETBYTE ();
11819               switch (op[2] & 0xf0)
11820               {
11821                 case 0x20:
11822                   goto op_semantics_98;
11823                   break;
11824                 case 0x40:
11825                   goto op_semantics_99;
11826                   break;
11827                 case 0x50:
11828                   goto op_semantics_100;
11829                   break;
11830                 case 0x60:
11831                   goto op_semantics_101;
11832                   break;
11833                 case 0x70:
11834                   goto op_semantics_102;
11835                   break;
11836                 case 0x80:
11837                   goto op_semantics_103;
11838                   break;
11839                 case 0x90:
11840                   goto op_semantics_104;
11841                   break;
11842                 case 0xc0:
11843                   goto op_semantics_105;
11844                   break;
11845                 case 0xd0:
11846                   goto op_semantics_106;
11847                   break;
11848                 case 0xe0:
11849                   goto op_semantics_107;
11850                   break;
11851                 case 0xf0:
11852                   goto op_semantics_108;
11853                   break;
11854                 default: UNSUPPORTED(); break;
11855               }
11856             break;
11857           case 0x7f:
11858               GETBYTE ();
11859               switch (op[2] & 0xe0)
11860               {
11861                 case 0x00:
11862                   goto op_semantics_109;
11863                   break;
11864                 default: UNSUPPORTED(); break;
11865               }
11866             break;
11867           case 0x80:
11868               GETBYTE ();
11869               switch (op[2] & 0x00)
11870               {
11871                 case 0x00:
11872                   op_semantics_110:
11873                     {
11874                       /** 1111 1101 100immmm rsrc rdst  shlr    #%2, %1, %0 */
11875 #line 732 "rx-decode.opc"
11876                       int immmm AU = op[1] & 0x1f;
11877 #line 732 "rx-decode.opc"
11878                       int rsrc AU = (op[2] >> 4) & 0x0f;
11879 #line 732 "rx-decode.opc"
11880                       int rdst AU = op[2] & 0x0f;
11881                       if (trace)
11882                         {
11883                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11884                                  "/** 1111 1101 100immmm rsrc rdst      shlr    #%2, %1, %0 */",
11885                                  op[0], op[1], op[2]);
11886                           printf ("  immmm = 0x%x,", immmm);
11887                           printf ("  rsrc = 0x%x,", rsrc);
11888                           printf ("  rdst = 0x%x\n", rdst);
11889                         }
11890                       SYNTAX("shlr      #%2, %1, %0");
11891 #line 732 "rx-decode.opc"
11892                       ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
11893
11894                     /*----------------------------------------------------------------------*/
11895                     /* ROTATE                                                           */
11896
11897                     }
11898                   break;
11899               }
11900             break;
11901           case 0x81:
11902               GETBYTE ();
11903               switch (op[2] & 0x00)
11904               {
11905                 case 0x00:
11906                   goto op_semantics_110;
11907                   break;
11908               }
11909             break;
11910           case 0x82:
11911               GETBYTE ();
11912               switch (op[2] & 0x00)
11913               {
11914                 case 0x00:
11915                   goto op_semantics_110;
11916                   break;
11917               }
11918             break;
11919           case 0x83:
11920               GETBYTE ();
11921               switch (op[2] & 0x00)
11922               {
11923                 case 0x00:
11924                   goto op_semantics_110;
11925                   break;
11926               }
11927             break;
11928           case 0x84:
11929               GETBYTE ();
11930               switch (op[2] & 0x00)
11931               {
11932                 case 0x00:
11933                   goto op_semantics_110;
11934                   break;
11935               }
11936             break;
11937           case 0x85:
11938               GETBYTE ();
11939               switch (op[2] & 0x00)
11940               {
11941                 case 0x00:
11942                   goto op_semantics_110;
11943                   break;
11944               }
11945             break;
11946           case 0x86:
11947               GETBYTE ();
11948               switch (op[2] & 0x00)
11949               {
11950                 case 0x00:
11951                   goto op_semantics_110;
11952                   break;
11953               }
11954             break;
11955           case 0x87:
11956               GETBYTE ();
11957               switch (op[2] & 0x00)
11958               {
11959                 case 0x00:
11960                   goto op_semantics_110;
11961                   break;
11962               }
11963             break;
11964           case 0x88:
11965               GETBYTE ();
11966               switch (op[2] & 0x00)
11967               {
11968                 case 0x00:
11969                   goto op_semantics_110;
11970                   break;
11971               }
11972             break;
11973           case 0x89:
11974               GETBYTE ();
11975               switch (op[2] & 0x00)
11976               {
11977                 case 0x00:
11978                   goto op_semantics_110;
11979                   break;
11980               }
11981             break;
11982           case 0x8a:
11983               GETBYTE ();
11984               switch (op[2] & 0x00)
11985               {
11986                 case 0x00:
11987                   goto op_semantics_110;
11988                   break;
11989               }
11990             break;
11991           case 0x8b:
11992               GETBYTE ();
11993               switch (op[2] & 0x00)
11994               {
11995                 case 0x00:
11996                   goto op_semantics_110;
11997                   break;
11998               }
11999             break;
12000           case 0x8c:
12001               GETBYTE ();
12002               switch (op[2] & 0x00)
12003               {
12004                 case 0x00:
12005                   goto op_semantics_110;
12006                   break;
12007               }
12008             break;
12009           case 0x8d:
12010               GETBYTE ();
12011               switch (op[2] & 0x00)
12012               {
12013                 case 0x00:
12014                   goto op_semantics_110;
12015                   break;
12016               }
12017             break;
12018           case 0x8e:
12019               GETBYTE ();
12020               switch (op[2] & 0x00)
12021               {
12022                 case 0x00:
12023                   goto op_semantics_110;
12024                   break;
12025               }
12026             break;
12027           case 0x8f:
12028               GETBYTE ();
12029               switch (op[2] & 0x00)
12030               {
12031                 case 0x00:
12032                   goto op_semantics_110;
12033                   break;
12034               }
12035             break;
12036           case 0x90:
12037               GETBYTE ();
12038               switch (op[2] & 0x00)
12039               {
12040                 case 0x00:
12041                   goto op_semantics_110;
12042                   break;
12043               }
12044             break;
12045           case 0x91:
12046               GETBYTE ();
12047               switch (op[2] & 0x00)
12048               {
12049                 case 0x00:
12050                   goto op_semantics_110;
12051                   break;
12052               }
12053             break;
12054           case 0x92:
12055               GETBYTE ();
12056               switch (op[2] & 0x00)
12057               {
12058                 case 0x00:
12059                   goto op_semantics_110;
12060                   break;
12061               }
12062             break;
12063           case 0x93:
12064               GETBYTE ();
12065               switch (op[2] & 0x00)
12066               {
12067                 case 0x00:
12068                   goto op_semantics_110;
12069                   break;
12070               }
12071             break;
12072           case 0x94:
12073               GETBYTE ();
12074               switch (op[2] & 0x00)
12075               {
12076                 case 0x00:
12077                   goto op_semantics_110;
12078                   break;
12079               }
12080             break;
12081           case 0x95:
12082               GETBYTE ();
12083               switch (op[2] & 0x00)
12084               {
12085                 case 0x00:
12086                   goto op_semantics_110;
12087                   break;
12088               }
12089             break;
12090           case 0x96:
12091               GETBYTE ();
12092               switch (op[2] & 0x00)
12093               {
12094                 case 0x00:
12095                   goto op_semantics_110;
12096                   break;
12097               }
12098             break;
12099           case 0x97:
12100               GETBYTE ();
12101               switch (op[2] & 0x00)
12102               {
12103                 case 0x00:
12104                   goto op_semantics_110;
12105                   break;
12106               }
12107             break;
12108           case 0x98:
12109               GETBYTE ();
12110               switch (op[2] & 0x00)
12111               {
12112                 case 0x00:
12113                   goto op_semantics_110;
12114                   break;
12115               }
12116             break;
12117           case 0x99:
12118               GETBYTE ();
12119               switch (op[2] & 0x00)
12120               {
12121                 case 0x00:
12122                   goto op_semantics_110;
12123                   break;
12124               }
12125             break;
12126           case 0x9a:
12127               GETBYTE ();
12128               switch (op[2] & 0x00)
12129               {
12130                 case 0x00:
12131                   goto op_semantics_110;
12132                   break;
12133               }
12134             break;
12135           case 0x9b:
12136               GETBYTE ();
12137               switch (op[2] & 0x00)
12138               {
12139                 case 0x00:
12140                   goto op_semantics_110;
12141                   break;
12142               }
12143             break;
12144           case 0x9c:
12145               GETBYTE ();
12146               switch (op[2] & 0x00)
12147               {
12148                 case 0x00:
12149                   goto op_semantics_110;
12150                   break;
12151               }
12152             break;
12153           case 0x9d:
12154               GETBYTE ();
12155               switch (op[2] & 0x00)
12156               {
12157                 case 0x00:
12158                   goto op_semantics_110;
12159                   break;
12160               }
12161             break;
12162           case 0x9e:
12163               GETBYTE ();
12164               switch (op[2] & 0x00)
12165               {
12166                 case 0x00:
12167                   goto op_semantics_110;
12168                   break;
12169               }
12170             break;
12171           case 0x9f:
12172               GETBYTE ();
12173               switch (op[2] & 0x00)
12174               {
12175                 case 0x00:
12176                   goto op_semantics_110;
12177                   break;
12178               }
12179             break;
12180           case 0xa0:
12181               GETBYTE ();
12182               switch (op[2] & 0x00)
12183               {
12184                 case 0x00:
12185                   op_semantics_111:
12186                     {
12187                       /** 1111 1101 101immmm rsrc rdst  shar    #%2, %1, %0 */
12188 #line 722 "rx-decode.opc"
12189                       int immmm AU = op[1] & 0x1f;
12190 #line 722 "rx-decode.opc"
12191                       int rsrc AU = (op[2] >> 4) & 0x0f;
12192 #line 722 "rx-decode.opc"
12193                       int rdst AU = op[2] & 0x0f;
12194                       if (trace)
12195                         {
12196                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12197                                  "/** 1111 1101 101immmm rsrc rdst      shar    #%2, %1, %0 */",
12198                                  op[0], op[1], op[2]);
12199                           printf ("  immmm = 0x%x,", immmm);
12200                           printf ("  rsrc = 0x%x,", rsrc);
12201                           printf ("  rdst = 0x%x\n", rdst);
12202                         }
12203                       SYNTAX("shar      #%2, %1, %0");
12204 #line 722 "rx-decode.opc"
12205                       ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
12206
12207
12208                     }
12209                   break;
12210               }
12211             break;
12212           case 0xa1:
12213               GETBYTE ();
12214               switch (op[2] & 0x00)
12215               {
12216                 case 0x00:
12217                   goto op_semantics_111;
12218                   break;
12219               }
12220             break;
12221           case 0xa2:
12222               GETBYTE ();
12223               switch (op[2] & 0x00)
12224               {
12225                 case 0x00:
12226                   goto op_semantics_111;
12227                   break;
12228               }
12229             break;
12230           case 0xa3:
12231               GETBYTE ();
12232               switch (op[2] & 0x00)
12233               {
12234                 case 0x00:
12235                   goto op_semantics_111;
12236                   break;
12237               }
12238             break;
12239           case 0xa4:
12240               GETBYTE ();
12241               switch (op[2] & 0x00)
12242               {
12243                 case 0x00:
12244                   goto op_semantics_111;
12245                   break;
12246               }
12247             break;
12248           case 0xa5:
12249               GETBYTE ();
12250               switch (op[2] & 0x00)
12251               {
12252                 case 0x00:
12253                   goto op_semantics_111;
12254                   break;
12255               }
12256             break;
12257           case 0xa6:
12258               GETBYTE ();
12259               switch (op[2] & 0x00)
12260               {
12261                 case 0x00:
12262                   goto op_semantics_111;
12263                   break;
12264               }
12265             break;
12266           case 0xa7:
12267               GETBYTE ();
12268               switch (op[2] & 0x00)
12269               {
12270                 case 0x00:
12271                   goto op_semantics_111;
12272                   break;
12273               }
12274             break;
12275           case 0xa8:
12276               GETBYTE ();
12277               switch (op[2] & 0x00)
12278               {
12279                 case 0x00:
12280                   goto op_semantics_111;
12281                   break;
12282               }
12283             break;
12284           case 0xa9:
12285               GETBYTE ();
12286               switch (op[2] & 0x00)
12287               {
12288                 case 0x00:
12289                   goto op_semantics_111;
12290                   break;
12291               }
12292             break;
12293           case 0xaa:
12294               GETBYTE ();
12295               switch (op[2] & 0x00)
12296               {
12297                 case 0x00:
12298                   goto op_semantics_111;
12299                   break;
12300               }
12301             break;
12302           case 0xab:
12303               GETBYTE ();
12304               switch (op[2] & 0x00)
12305               {
12306                 case 0x00:
12307                   goto op_semantics_111;
12308                   break;
12309               }
12310             break;
12311           case 0xac:
12312               GETBYTE ();
12313               switch (op[2] & 0x00)
12314               {
12315                 case 0x00:
12316                   goto op_semantics_111;
12317                   break;
12318               }
12319             break;
12320           case 0xad:
12321               GETBYTE ();
12322               switch (op[2] & 0x00)
12323               {
12324                 case 0x00:
12325                   goto op_semantics_111;
12326                   break;
12327               }
12328             break;
12329           case 0xae:
12330               GETBYTE ();
12331               switch (op[2] & 0x00)
12332               {
12333                 case 0x00:
12334                   goto op_semantics_111;
12335                   break;
12336               }
12337             break;
12338           case 0xaf:
12339               GETBYTE ();
12340               switch (op[2] & 0x00)
12341               {
12342                 case 0x00:
12343                   goto op_semantics_111;
12344                   break;
12345               }
12346             break;
12347           case 0xb0:
12348               GETBYTE ();
12349               switch (op[2] & 0x00)
12350               {
12351                 case 0x00:
12352                   goto op_semantics_111;
12353                   break;
12354               }
12355             break;
12356           case 0xb1:
12357               GETBYTE ();
12358               switch (op[2] & 0x00)
12359               {
12360                 case 0x00:
12361                   goto op_semantics_111;
12362                   break;
12363               }
12364             break;
12365           case 0xb2:
12366               GETBYTE ();
12367               switch (op[2] & 0x00)
12368               {
12369                 case 0x00:
12370                   goto op_semantics_111;
12371                   break;
12372               }
12373             break;
12374           case 0xb3:
12375               GETBYTE ();
12376               switch (op[2] & 0x00)
12377               {
12378                 case 0x00:
12379                   goto op_semantics_111;
12380                   break;
12381               }
12382             break;
12383           case 0xb4:
12384               GETBYTE ();
12385               switch (op[2] & 0x00)
12386               {
12387                 case 0x00:
12388                   goto op_semantics_111;
12389                   break;
12390               }
12391             break;
12392           case 0xb5:
12393               GETBYTE ();
12394               switch (op[2] & 0x00)
12395               {
12396                 case 0x00:
12397                   goto op_semantics_111;
12398                   break;
12399               }
12400             break;
12401           case 0xb6:
12402               GETBYTE ();
12403               switch (op[2] & 0x00)
12404               {
12405                 case 0x00:
12406                   goto op_semantics_111;
12407                   break;
12408               }
12409             break;
12410           case 0xb7:
12411               GETBYTE ();
12412               switch (op[2] & 0x00)
12413               {
12414                 case 0x00:
12415                   goto op_semantics_111;
12416                   break;
12417               }
12418             break;
12419           case 0xb8:
12420               GETBYTE ();
12421               switch (op[2] & 0x00)
12422               {
12423                 case 0x00:
12424                   goto op_semantics_111;
12425                   break;
12426               }
12427             break;
12428           case 0xb9:
12429               GETBYTE ();
12430               switch (op[2] & 0x00)
12431               {
12432                 case 0x00:
12433                   goto op_semantics_111;
12434                   break;
12435               }
12436             break;
12437           case 0xba:
12438               GETBYTE ();
12439               switch (op[2] & 0x00)
12440               {
12441                 case 0x00:
12442                   goto op_semantics_111;
12443                   break;
12444               }
12445             break;
12446           case 0xbb:
12447               GETBYTE ();
12448               switch (op[2] & 0x00)
12449               {
12450                 case 0x00:
12451                   goto op_semantics_111;
12452                   break;
12453               }
12454             break;
12455           case 0xbc:
12456               GETBYTE ();
12457               switch (op[2] & 0x00)
12458               {
12459                 case 0x00:
12460                   goto op_semantics_111;
12461                   break;
12462               }
12463             break;
12464           case 0xbd:
12465               GETBYTE ();
12466               switch (op[2] & 0x00)
12467               {
12468                 case 0x00:
12469                   goto op_semantics_111;
12470                   break;
12471               }
12472             break;
12473           case 0xbe:
12474               GETBYTE ();
12475               switch (op[2] & 0x00)
12476               {
12477                 case 0x00:
12478                   goto op_semantics_111;
12479                   break;
12480               }
12481             break;
12482           case 0xbf:
12483               GETBYTE ();
12484               switch (op[2] & 0x00)
12485               {
12486                 case 0x00:
12487                   goto op_semantics_111;
12488                   break;
12489               }
12490             break;
12491           case 0xc0:
12492               GETBYTE ();
12493               switch (op[2] & 0x00)
12494               {
12495                 case 0x00:
12496                   op_semantics_112:
12497                     {
12498                       /** 1111 1101 110immmm rsrc rdst  shll    #%2, %1, %0 */
12499 #line 712 "rx-decode.opc"
12500                       int immmm AU = op[1] & 0x1f;
12501 #line 712 "rx-decode.opc"
12502                       int rsrc AU = (op[2] >> 4) & 0x0f;
12503 #line 712 "rx-decode.opc"
12504                       int rdst AU = op[2] & 0x0f;
12505                       if (trace)
12506                         {
12507                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12508                                  "/** 1111 1101 110immmm rsrc rdst      shll    #%2, %1, %0 */",
12509                                  op[0], op[1], op[2]);
12510                           printf ("  immmm = 0x%x,", immmm);
12511                           printf ("  rsrc = 0x%x,", rsrc);
12512                           printf ("  rdst = 0x%x\n", rdst);
12513                         }
12514                       SYNTAX("shll      #%2, %1, %0");
12515 #line 712 "rx-decode.opc"
12516                       ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
12517
12518
12519                     }
12520                   break;
12521               }
12522             break;
12523           case 0xc1:
12524               GETBYTE ();
12525               switch (op[2] & 0x00)
12526               {
12527                 case 0x00:
12528                   goto op_semantics_112;
12529                   break;
12530               }
12531             break;
12532           case 0xc2:
12533               GETBYTE ();
12534               switch (op[2] & 0x00)
12535               {
12536                 case 0x00:
12537                   goto op_semantics_112;
12538                   break;
12539               }
12540             break;
12541           case 0xc3:
12542               GETBYTE ();
12543               switch (op[2] & 0x00)
12544               {
12545                 case 0x00:
12546                   goto op_semantics_112;
12547                   break;
12548               }
12549             break;
12550           case 0xc4:
12551               GETBYTE ();
12552               switch (op[2] & 0x00)
12553               {
12554                 case 0x00:
12555                   goto op_semantics_112;
12556                   break;
12557               }
12558             break;
12559           case 0xc5:
12560               GETBYTE ();
12561               switch (op[2] & 0x00)
12562               {
12563                 case 0x00:
12564                   goto op_semantics_112;
12565                   break;
12566               }
12567             break;
12568           case 0xc6:
12569               GETBYTE ();
12570               switch (op[2] & 0x00)
12571               {
12572                 case 0x00:
12573                   goto op_semantics_112;
12574                   break;
12575               }
12576             break;
12577           case 0xc7:
12578               GETBYTE ();
12579               switch (op[2] & 0x00)
12580               {
12581                 case 0x00:
12582                   goto op_semantics_112;
12583                   break;
12584               }
12585             break;
12586           case 0xc8:
12587               GETBYTE ();
12588               switch (op[2] & 0x00)
12589               {
12590                 case 0x00:
12591                   goto op_semantics_112;
12592                   break;
12593               }
12594             break;
12595           case 0xc9:
12596               GETBYTE ();
12597               switch (op[2] & 0x00)
12598               {
12599                 case 0x00:
12600                   goto op_semantics_112;
12601                   break;
12602               }
12603             break;
12604           case 0xca:
12605               GETBYTE ();
12606               switch (op[2] & 0x00)
12607               {
12608                 case 0x00:
12609                   goto op_semantics_112;
12610                   break;
12611               }
12612             break;
12613           case 0xcb:
12614               GETBYTE ();
12615               switch (op[2] & 0x00)
12616               {
12617                 case 0x00:
12618                   goto op_semantics_112;
12619                   break;
12620               }
12621             break;
12622           case 0xcc:
12623               GETBYTE ();
12624               switch (op[2] & 0x00)
12625               {
12626                 case 0x00:
12627                   goto op_semantics_112;
12628                   break;
12629               }
12630             break;
12631           case 0xcd:
12632               GETBYTE ();
12633               switch (op[2] & 0x00)
12634               {
12635                 case 0x00:
12636                   goto op_semantics_112;
12637                   break;
12638               }
12639             break;
12640           case 0xce:
12641               GETBYTE ();
12642               switch (op[2] & 0x00)
12643               {
12644                 case 0x00:
12645                   goto op_semantics_112;
12646                   break;
12647               }
12648             break;
12649           case 0xcf:
12650               GETBYTE ();
12651               switch (op[2] & 0x00)
12652               {
12653                 case 0x00:
12654                   goto op_semantics_112;
12655                   break;
12656               }
12657             break;
12658           case 0xd0:
12659               GETBYTE ();
12660               switch (op[2] & 0x00)
12661               {
12662                 case 0x00:
12663                   goto op_semantics_112;
12664                   break;
12665               }
12666             break;
12667           case 0xd1:
12668               GETBYTE ();
12669               switch (op[2] & 0x00)
12670               {
12671                 case 0x00:
12672                   goto op_semantics_112;
12673                   break;
12674               }
12675             break;
12676           case 0xd2:
12677               GETBYTE ();
12678               switch (op[2] & 0x00)
12679               {
12680                 case 0x00:
12681                   goto op_semantics_112;
12682                   break;
12683               }
12684             break;
12685           case 0xd3:
12686               GETBYTE ();
12687               switch (op[2] & 0x00)
12688               {
12689                 case 0x00:
12690                   goto op_semantics_112;
12691                   break;
12692               }
12693             break;
12694           case 0xd4:
12695               GETBYTE ();
12696               switch (op[2] & 0x00)
12697               {
12698                 case 0x00:
12699                   goto op_semantics_112;
12700                   break;
12701               }
12702             break;
12703           case 0xd5:
12704               GETBYTE ();
12705               switch (op[2] & 0x00)
12706               {
12707                 case 0x00:
12708                   goto op_semantics_112;
12709                   break;
12710               }
12711             break;
12712           case 0xd6:
12713               GETBYTE ();
12714               switch (op[2] & 0x00)
12715               {
12716                 case 0x00:
12717                   goto op_semantics_112;
12718                   break;
12719               }
12720             break;
12721           case 0xd7:
12722               GETBYTE ();
12723               switch (op[2] & 0x00)
12724               {
12725                 case 0x00:
12726                   goto op_semantics_112;
12727                   break;
12728               }
12729             break;
12730           case 0xd8:
12731               GETBYTE ();
12732               switch (op[2] & 0x00)
12733               {
12734                 case 0x00:
12735                   goto op_semantics_112;
12736                   break;
12737               }
12738             break;
12739           case 0xd9:
12740               GETBYTE ();
12741               switch (op[2] & 0x00)
12742               {
12743                 case 0x00:
12744                   goto op_semantics_112;
12745                   break;
12746               }
12747             break;
12748           case 0xda:
12749               GETBYTE ();
12750               switch (op[2] & 0x00)
12751               {
12752                 case 0x00:
12753                   goto op_semantics_112;
12754                   break;
12755               }
12756             break;
12757           case 0xdb:
12758               GETBYTE ();
12759               switch (op[2] & 0x00)
12760               {
12761                 case 0x00:
12762                   goto op_semantics_112;
12763                   break;
12764               }
12765             break;
12766           case 0xdc:
12767               GETBYTE ();
12768               switch (op[2] & 0x00)
12769               {
12770                 case 0x00:
12771                   goto op_semantics_112;
12772                   break;
12773               }
12774             break;
12775           case 0xdd:
12776               GETBYTE ();
12777               switch (op[2] & 0x00)
12778               {
12779                 case 0x00:
12780                   goto op_semantics_112;
12781                   break;
12782               }
12783             break;
12784           case 0xde:
12785               GETBYTE ();
12786               switch (op[2] & 0x00)
12787               {
12788                 case 0x00:
12789                   goto op_semantics_112;
12790                   break;
12791               }
12792             break;
12793           case 0xdf:
12794               GETBYTE ();
12795               switch (op[2] & 0x00)
12796               {
12797                 case 0x00:
12798                   goto op_semantics_112;
12799                   break;
12800               }
12801             break;
12802           case 0xe0:
12803               GETBYTE ();
12804               switch (op[2] & 0xf0)
12805               {
12806                 case 0x00:
12807                 case 0x10:
12808                 case 0x20:
12809                 case 0x30:
12810                 case 0x40:
12811                 case 0x50:
12812                 case 0x60:
12813                 case 0x70:
12814                 case 0x80:
12815                 case 0x90:
12816                 case 0xa0:
12817                 case 0xb0:
12818                 case 0xc0:
12819                 case 0xd0:
12820                 case 0xe0:
12821                   op_semantics_113:
12822                     {
12823                       /** 1111 1101 111 bittt cond rdst bm%2    #%1, %0%S0 */
12824 #line 986 "rx-decode.opc"
12825                       int bittt AU = op[1] & 0x1f;
12826 #line 986 "rx-decode.opc"
12827                       int cond AU = (op[2] >> 4) & 0x0f;
12828 #line 986 "rx-decode.opc"
12829                       int rdst AU = op[2] & 0x0f;
12830                       if (trace)
12831                         {
12832                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12833                                  "/** 1111 1101 111 bittt cond rdst     bm%2    #%1, %0%S0 */",
12834                                  op[0], op[1], op[2]);
12835                           printf ("  bittt = 0x%x,", bittt);
12836                           printf ("  cond = 0x%x,", cond);
12837                           printf ("  rdst = 0x%x\n", rdst);
12838                         }
12839                       SYNTAX("bm%2      #%1, %0%S0");
12840 #line 986 "rx-decode.opc"
12841                       ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
12842
12843                     /*----------------------------------------------------------------------*/
12844                     /* CONTROL REGISTERS                                                        */
12845
12846                     }
12847                   break;
12848                 case 0xf0:
12849                   op_semantics_114:
12850                     {
12851                       /** 1111 1101 111bittt 1111 rdst  bnot    #%1, %0 */
12852 #line 979 "rx-decode.opc"
12853                       int bittt AU = op[1] & 0x1f;
12854 #line 979 "rx-decode.opc"
12855                       int rdst AU = op[2] & 0x0f;
12856                       if (trace)
12857                         {
12858                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12859                                  "/** 1111 1101 111bittt 1111 rdst      bnot    #%1, %0 */",
12860                                  op[0], op[1], op[2]);
12861                           printf ("  bittt = 0x%x,", bittt);
12862                           printf ("  rdst = 0x%x\n", rdst);
12863                         }
12864                       SYNTAX("bnot      #%1, %0");
12865 #line 979 "rx-decode.opc"
12866                       ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
12867
12868
12869                     }
12870                   break;
12871               }
12872             break;
12873           case 0xe1:
12874               GETBYTE ();
12875               switch (op[2] & 0xf0)
12876               {
12877                 case 0x00:
12878                 case 0x10:
12879                 case 0x20:
12880                 case 0x30:
12881                 case 0x40:
12882                 case 0x50:
12883                 case 0x60:
12884                 case 0x70:
12885                 case 0x80:
12886                 case 0x90:
12887                 case 0xa0:
12888                 case 0xb0:
12889                 case 0xc0:
12890                 case 0xd0:
12891                 case 0xe0:
12892                   goto op_semantics_113;
12893                   break;
12894                 case 0xf0:
12895                   goto op_semantics_114;
12896                   break;
12897               }
12898             break;
12899           case 0xe2:
12900               GETBYTE ();
12901               switch (op[2] & 0xf0)
12902               {
12903                 case 0x00:
12904                 case 0x10:
12905                 case 0x20:
12906                 case 0x30:
12907                 case 0x40:
12908                 case 0x50:
12909                 case 0x60:
12910                 case 0x70:
12911                 case 0x80:
12912                 case 0x90:
12913                 case 0xa0:
12914                 case 0xb0:
12915                 case 0xc0:
12916                 case 0xd0:
12917                 case 0xe0:
12918                   goto op_semantics_113;
12919                   break;
12920                 case 0xf0:
12921                   goto op_semantics_114;
12922                   break;
12923               }
12924             break;
12925           case 0xe3:
12926               GETBYTE ();
12927               switch (op[2] & 0xf0)
12928               {
12929                 case 0x00:
12930                 case 0x10:
12931                 case 0x20:
12932                 case 0x30:
12933                 case 0x40:
12934                 case 0x50:
12935                 case 0x60:
12936                 case 0x70:
12937                 case 0x80:
12938                 case 0x90:
12939                 case 0xa0:
12940                 case 0xb0:
12941                 case 0xc0:
12942                 case 0xd0:
12943                 case 0xe0:
12944                   goto op_semantics_113;
12945                   break;
12946                 case 0xf0:
12947                   goto op_semantics_114;
12948                   break;
12949               }
12950             break;
12951           case 0xe4:
12952               GETBYTE ();
12953               switch (op[2] & 0xf0)
12954               {
12955                 case 0x00:
12956                 case 0x10:
12957                 case 0x20:
12958                 case 0x30:
12959                 case 0x40:
12960                 case 0x50:
12961                 case 0x60:
12962                 case 0x70:
12963                 case 0x80:
12964                 case 0x90:
12965                 case 0xa0:
12966                 case 0xb0:
12967                 case 0xc0:
12968                 case 0xd0:
12969                 case 0xe0:
12970                   goto op_semantics_113;
12971                   break;
12972                 case 0xf0:
12973                   goto op_semantics_114;
12974                   break;
12975               }
12976             break;
12977           case 0xe5:
12978               GETBYTE ();
12979               switch (op[2] & 0xf0)
12980               {
12981                 case 0x00:
12982                 case 0x10:
12983                 case 0x20:
12984                 case 0x30:
12985                 case 0x40:
12986                 case 0x50:
12987                 case 0x60:
12988                 case 0x70:
12989                 case 0x80:
12990                 case 0x90:
12991                 case 0xa0:
12992                 case 0xb0:
12993                 case 0xc0:
12994                 case 0xd0:
12995                 case 0xe0:
12996                   goto op_semantics_113;
12997                   break;
12998                 case 0xf0:
12999                   goto op_semantics_114;
13000                   break;
13001               }
13002             break;
13003           case 0xe6:
13004               GETBYTE ();
13005               switch (op[2] & 0xf0)
13006               {
13007                 case 0x00:
13008                 case 0x10:
13009                 case 0x20:
13010                 case 0x30:
13011                 case 0x40:
13012                 case 0x50:
13013                 case 0x60:
13014                 case 0x70:
13015                 case 0x80:
13016                 case 0x90:
13017                 case 0xa0:
13018                 case 0xb0:
13019                 case 0xc0:
13020                 case 0xd0:
13021                 case 0xe0:
13022                   goto op_semantics_113;
13023                   break;
13024                 case 0xf0:
13025                   goto op_semantics_114;
13026                   break;
13027               }
13028             break;
13029           case 0xe7:
13030               GETBYTE ();
13031               switch (op[2] & 0xf0)
13032               {
13033                 case 0x00:
13034                 case 0x10:
13035                 case 0x20:
13036                 case 0x30:
13037                 case 0x40:
13038                 case 0x50:
13039                 case 0x60:
13040                 case 0x70:
13041                 case 0x80:
13042                 case 0x90:
13043                 case 0xa0:
13044                 case 0xb0:
13045                 case 0xc0:
13046                 case 0xd0:
13047                 case 0xe0:
13048                   goto op_semantics_113;
13049                   break;
13050                 case 0xf0:
13051                   goto op_semantics_114;
13052                   break;
13053               }
13054             break;
13055           case 0xe8:
13056               GETBYTE ();
13057               switch (op[2] & 0xf0)
13058               {
13059                 case 0x00:
13060                 case 0x10:
13061                 case 0x20:
13062                 case 0x30:
13063                 case 0x40:
13064                 case 0x50:
13065                 case 0x60:
13066                 case 0x70:
13067                 case 0x80:
13068                 case 0x90:
13069                 case 0xa0:
13070                 case 0xb0:
13071                 case 0xc0:
13072                 case 0xd0:
13073                 case 0xe0:
13074                   goto op_semantics_113;
13075                   break;
13076                 case 0xf0:
13077                   goto op_semantics_114;
13078                   break;
13079               }
13080             break;
13081           case 0xe9:
13082               GETBYTE ();
13083               switch (op[2] & 0xf0)
13084               {
13085                 case 0x00:
13086                 case 0x10:
13087                 case 0x20:
13088                 case 0x30:
13089                 case 0x40:
13090                 case 0x50:
13091                 case 0x60:
13092                 case 0x70:
13093                 case 0x80:
13094                 case 0x90:
13095                 case 0xa0:
13096                 case 0xb0:
13097                 case 0xc0:
13098                 case 0xd0:
13099                 case 0xe0:
13100                   goto op_semantics_113;
13101                   break;
13102                 case 0xf0:
13103                   goto op_semantics_114;
13104                   break;
13105               }
13106             break;
13107           case 0xea:
13108               GETBYTE ();
13109               switch (op[2] & 0xf0)
13110               {
13111                 case 0x00:
13112                 case 0x10:
13113                 case 0x20:
13114                 case 0x30:
13115                 case 0x40:
13116                 case 0x50:
13117                 case 0x60:
13118                 case 0x70:
13119                 case 0x80:
13120                 case 0x90:
13121                 case 0xa0:
13122                 case 0xb0:
13123                 case 0xc0:
13124                 case 0xd0:
13125                 case 0xe0:
13126                   goto op_semantics_113;
13127                   break;
13128                 case 0xf0:
13129                   goto op_semantics_114;
13130                   break;
13131               }
13132             break;
13133           case 0xeb:
13134               GETBYTE ();
13135               switch (op[2] & 0xf0)
13136               {
13137                 case 0x00:
13138                 case 0x10:
13139                 case 0x20:
13140                 case 0x30:
13141                 case 0x40:
13142                 case 0x50:
13143                 case 0x60:
13144                 case 0x70:
13145                 case 0x80:
13146                 case 0x90:
13147                 case 0xa0:
13148                 case 0xb0:
13149                 case 0xc0:
13150                 case 0xd0:
13151                 case 0xe0:
13152                   goto op_semantics_113;
13153                   break;
13154                 case 0xf0:
13155                   goto op_semantics_114;
13156                   break;
13157               }
13158             break;
13159           case 0xec:
13160               GETBYTE ();
13161               switch (op[2] & 0xf0)
13162               {
13163                 case 0x00:
13164                 case 0x10:
13165                 case 0x20:
13166                 case 0x30:
13167                 case 0x40:
13168                 case 0x50:
13169                 case 0x60:
13170                 case 0x70:
13171                 case 0x80:
13172                 case 0x90:
13173                 case 0xa0:
13174                 case 0xb0:
13175                 case 0xc0:
13176                 case 0xd0:
13177                 case 0xe0:
13178                   goto op_semantics_113;
13179                   break;
13180                 case 0xf0:
13181                   goto op_semantics_114;
13182                   break;
13183               }
13184             break;
13185           case 0xed:
13186               GETBYTE ();
13187               switch (op[2] & 0xf0)
13188               {
13189                 case 0x00:
13190                 case 0x10:
13191                 case 0x20:
13192                 case 0x30:
13193                 case 0x40:
13194                 case 0x50:
13195                 case 0x60:
13196                 case 0x70:
13197                 case 0x80:
13198                 case 0x90:
13199                 case 0xa0:
13200                 case 0xb0:
13201                 case 0xc0:
13202                 case 0xd0:
13203                 case 0xe0:
13204                   goto op_semantics_113;
13205                   break;
13206                 case 0xf0:
13207                   goto op_semantics_114;
13208                   break;
13209               }
13210             break;
13211           case 0xee:
13212               GETBYTE ();
13213               switch (op[2] & 0xf0)
13214               {
13215                 case 0x00:
13216                 case 0x10:
13217                 case 0x20:
13218                 case 0x30:
13219                 case 0x40:
13220                 case 0x50:
13221                 case 0x60:
13222                 case 0x70:
13223                 case 0x80:
13224                 case 0x90:
13225                 case 0xa0:
13226                 case 0xb0:
13227                 case 0xc0:
13228                 case 0xd0:
13229                 case 0xe0:
13230                   goto op_semantics_113;
13231                   break;
13232                 case 0xf0:
13233                   goto op_semantics_114;
13234                   break;
13235               }
13236             break;
13237           case 0xef:
13238               GETBYTE ();
13239               switch (op[2] & 0xf0)
13240               {
13241                 case 0x00:
13242                 case 0x10:
13243                 case 0x20:
13244                 case 0x30:
13245                 case 0x40:
13246                 case 0x50:
13247                 case 0x60:
13248                 case 0x70:
13249                 case 0x80:
13250                 case 0x90:
13251                 case 0xa0:
13252                 case 0xb0:
13253                 case 0xc0:
13254                 case 0xd0:
13255                 case 0xe0:
13256                   goto op_semantics_113;
13257                   break;
13258                 case 0xf0:
13259                   goto op_semantics_114;
13260                   break;
13261               }
13262             break;
13263           case 0xf0:
13264               GETBYTE ();
13265               switch (op[2] & 0xf0)
13266               {
13267                 case 0x00:
13268                 case 0x10:
13269                 case 0x20:
13270                 case 0x30:
13271                 case 0x40:
13272                 case 0x50:
13273                 case 0x60:
13274                 case 0x70:
13275                 case 0x80:
13276                 case 0x90:
13277                 case 0xa0:
13278                 case 0xb0:
13279                 case 0xc0:
13280                 case 0xd0:
13281                 case 0xe0:
13282                   goto op_semantics_113;
13283                   break;
13284                 case 0xf0:
13285                   goto op_semantics_114;
13286                   break;
13287               }
13288             break;
13289           case 0xf1:
13290               GETBYTE ();
13291               switch (op[2] & 0xf0)
13292               {
13293                 case 0x00:
13294                 case 0x10:
13295                 case 0x20:
13296                 case 0x30:
13297                 case 0x40:
13298                 case 0x50:
13299                 case 0x60:
13300                 case 0x70:
13301                 case 0x80:
13302                 case 0x90:
13303                 case 0xa0:
13304                 case 0xb0:
13305                 case 0xc0:
13306                 case 0xd0:
13307                 case 0xe0:
13308                   goto op_semantics_113;
13309                   break;
13310                 case 0xf0:
13311                   goto op_semantics_114;
13312                   break;
13313               }
13314             break;
13315           case 0xf2:
13316               GETBYTE ();
13317               switch (op[2] & 0xf0)
13318               {
13319                 case 0x00:
13320                 case 0x10:
13321                 case 0x20:
13322                 case 0x30:
13323                 case 0x40:
13324                 case 0x50:
13325                 case 0x60:
13326                 case 0x70:
13327                 case 0x80:
13328                 case 0x90:
13329                 case 0xa0:
13330                 case 0xb0:
13331                 case 0xc0:
13332                 case 0xd0:
13333                 case 0xe0:
13334                   goto op_semantics_113;
13335                   break;
13336                 case 0xf0:
13337                   goto op_semantics_114;
13338                   break;
13339               }
13340             break;
13341           case 0xf3:
13342               GETBYTE ();
13343               switch (op[2] & 0xf0)
13344               {
13345                 case 0x00:
13346                 case 0x10:
13347                 case 0x20:
13348                 case 0x30:
13349                 case 0x40:
13350                 case 0x50:
13351                 case 0x60:
13352                 case 0x70:
13353                 case 0x80:
13354                 case 0x90:
13355                 case 0xa0:
13356                 case 0xb0:
13357                 case 0xc0:
13358                 case 0xd0:
13359                 case 0xe0:
13360                   goto op_semantics_113;
13361                   break;
13362                 case 0xf0:
13363                   goto op_semantics_114;
13364                   break;
13365               }
13366             break;
13367           case 0xf4:
13368               GETBYTE ();
13369               switch (op[2] & 0xf0)
13370               {
13371                 case 0x00:
13372                 case 0x10:
13373                 case 0x20:
13374                 case 0x30:
13375                 case 0x40:
13376                 case 0x50:
13377                 case 0x60:
13378                 case 0x70:
13379                 case 0x80:
13380                 case 0x90:
13381                 case 0xa0:
13382                 case 0xb0:
13383                 case 0xc0:
13384                 case 0xd0:
13385                 case 0xe0:
13386                   goto op_semantics_113;
13387                   break;
13388                 case 0xf0:
13389                   goto op_semantics_114;
13390                   break;
13391               }
13392             break;
13393           case 0xf5:
13394               GETBYTE ();
13395               switch (op[2] & 0xf0)
13396               {
13397                 case 0x00:
13398                 case 0x10:
13399                 case 0x20:
13400                 case 0x30:
13401                 case 0x40:
13402                 case 0x50:
13403                 case 0x60:
13404                 case 0x70:
13405                 case 0x80:
13406                 case 0x90:
13407                 case 0xa0:
13408                 case 0xb0:
13409                 case 0xc0:
13410                 case 0xd0:
13411                 case 0xe0:
13412                   goto op_semantics_113;
13413                   break;
13414                 case 0xf0:
13415                   goto op_semantics_114;
13416                   break;
13417               }
13418             break;
13419           case 0xf6:
13420               GETBYTE ();
13421               switch (op[2] & 0xf0)
13422               {
13423                 case 0x00:
13424                 case 0x10:
13425                 case 0x20:
13426                 case 0x30:
13427                 case 0x40:
13428                 case 0x50:
13429                 case 0x60:
13430                 case 0x70:
13431                 case 0x80:
13432                 case 0x90:
13433                 case 0xa0:
13434                 case 0xb0:
13435                 case 0xc0:
13436                 case 0xd0:
13437                 case 0xe0:
13438                   goto op_semantics_113;
13439                   break;
13440                 case 0xf0:
13441                   goto op_semantics_114;
13442                   break;
13443               }
13444             break;
13445           case 0xf7:
13446               GETBYTE ();
13447               switch (op[2] & 0xf0)
13448               {
13449                 case 0x00:
13450                 case 0x10:
13451                 case 0x20:
13452                 case 0x30:
13453                 case 0x40:
13454                 case 0x50:
13455                 case 0x60:
13456                 case 0x70:
13457                 case 0x80:
13458                 case 0x90:
13459                 case 0xa0:
13460                 case 0xb0:
13461                 case 0xc0:
13462                 case 0xd0:
13463                 case 0xe0:
13464                   goto op_semantics_113;
13465                   break;
13466                 case 0xf0:
13467                   goto op_semantics_114;
13468                   break;
13469               }
13470             break;
13471           case 0xf8:
13472               GETBYTE ();
13473               switch (op[2] & 0xf0)
13474               {
13475                 case 0x00:
13476                 case 0x10:
13477                 case 0x20:
13478                 case 0x30:
13479                 case 0x40:
13480                 case 0x50:
13481                 case 0x60:
13482                 case 0x70:
13483                 case 0x80:
13484                 case 0x90:
13485                 case 0xa0:
13486                 case 0xb0:
13487                 case 0xc0:
13488                 case 0xd0:
13489                 case 0xe0:
13490                   goto op_semantics_113;
13491                   break;
13492                 case 0xf0:
13493                   goto op_semantics_114;
13494                   break;
13495               }
13496             break;
13497           case 0xf9:
13498               GETBYTE ();
13499               switch (op[2] & 0xf0)
13500               {
13501                 case 0x00:
13502                 case 0x10:
13503                 case 0x20:
13504                 case 0x30:
13505                 case 0x40:
13506                 case 0x50:
13507                 case 0x60:
13508                 case 0x70:
13509                 case 0x80:
13510                 case 0x90:
13511                 case 0xa0:
13512                 case 0xb0:
13513                 case 0xc0:
13514                 case 0xd0:
13515                 case 0xe0:
13516                   goto op_semantics_113;
13517                   break;
13518                 case 0xf0:
13519                   goto op_semantics_114;
13520                   break;
13521               }
13522             break;
13523           case 0xfa:
13524               GETBYTE ();
13525               switch (op[2] & 0xf0)
13526               {
13527                 case 0x00:
13528                 case 0x10:
13529                 case 0x20:
13530                 case 0x30:
13531                 case 0x40:
13532                 case 0x50:
13533                 case 0x60:
13534                 case 0x70:
13535                 case 0x80:
13536                 case 0x90:
13537                 case 0xa0:
13538                 case 0xb0:
13539                 case 0xc0:
13540                 case 0xd0:
13541                 case 0xe0:
13542                   goto op_semantics_113;
13543                   break;
13544                 case 0xf0:
13545                   goto op_semantics_114;
13546                   break;
13547               }
13548             break;
13549           case 0xfb:
13550               GETBYTE ();
13551               switch (op[2] & 0xf0)
13552               {
13553                 case 0x00:
13554                 case 0x10:
13555                 case 0x20:
13556                 case 0x30:
13557                 case 0x40:
13558                 case 0x50:
13559                 case 0x60:
13560                 case 0x70:
13561                 case 0x80:
13562                 case 0x90:
13563                 case 0xa0:
13564                 case 0xb0:
13565                 case 0xc0:
13566                 case 0xd0:
13567                 case 0xe0:
13568                   goto op_semantics_113;
13569                   break;
13570                 case 0xf0:
13571                   goto op_semantics_114;
13572                   break;
13573               }
13574             break;
13575           case 0xfc:
13576               GETBYTE ();
13577               switch (op[2] & 0xf0)
13578               {
13579                 case 0x00:
13580                 case 0x10:
13581                 case 0x20:
13582                 case 0x30:
13583                 case 0x40:
13584                 case 0x50:
13585                 case 0x60:
13586                 case 0x70:
13587                 case 0x80:
13588                 case 0x90:
13589                 case 0xa0:
13590                 case 0xb0:
13591                 case 0xc0:
13592                 case 0xd0:
13593                 case 0xe0:
13594                   goto op_semantics_113;
13595                   break;
13596                 case 0xf0:
13597                   goto op_semantics_114;
13598                   break;
13599               }
13600             break;
13601           case 0xfd:
13602               GETBYTE ();
13603               switch (op[2] & 0xf0)
13604               {
13605                 case 0x00:
13606                 case 0x10:
13607                 case 0x20:
13608                 case 0x30:
13609                 case 0x40:
13610                 case 0x50:
13611                 case 0x60:
13612                 case 0x70:
13613                 case 0x80:
13614                 case 0x90:
13615                 case 0xa0:
13616                 case 0xb0:
13617                 case 0xc0:
13618                 case 0xd0:
13619                 case 0xe0:
13620                   goto op_semantics_113;
13621                   break;
13622                 case 0xf0:
13623                   goto op_semantics_114;
13624                   break;
13625               }
13626             break;
13627           case 0xfe:
13628               GETBYTE ();
13629               switch (op[2] & 0xf0)
13630               {
13631                 case 0x00:
13632                 case 0x10:
13633                 case 0x20:
13634                 case 0x30:
13635                 case 0x40:
13636                 case 0x50:
13637                 case 0x60:
13638                 case 0x70:
13639                 case 0x80:
13640                 case 0x90:
13641                 case 0xa0:
13642                 case 0xb0:
13643                 case 0xc0:
13644                 case 0xd0:
13645                 case 0xe0:
13646                   goto op_semantics_113;
13647                   break;
13648                 case 0xf0:
13649                   goto op_semantics_114;
13650                   break;
13651               }
13652             break;
13653           case 0xff:
13654               GETBYTE ();
13655               switch (op[2] & 0xf0)
13656               {
13657                 case 0x00:
13658                 case 0x10:
13659                 case 0x20:
13660                 case 0x30:
13661                 case 0x40:
13662                 case 0x50:
13663                 case 0x60:
13664                 case 0x70:
13665                 case 0x80:
13666                 case 0x90:
13667                 case 0xa0:
13668                 case 0xb0:
13669                 case 0xc0:
13670                 case 0xd0:
13671                 case 0xe0:
13672                   goto op_semantics_113;
13673                   break;
13674                 case 0xf0:
13675                   goto op_semantics_114;
13676                   break;
13677               }
13678             break;
13679           default: UNSUPPORTED(); break;
13680         }
13681       break;
13682     case 0xfe:
13683         GETBYTE ();
13684         switch (op[1] & 0xff)
13685         {
13686           case 0x00:
13687               GETBYTE ();
13688               switch (op[2] & 0x00)
13689               {
13690                 case 0x00:
13691                   op_semantics_115:
13692                     {
13693                       /** 1111 1110 00sz isrc bsrc rdst mov%s   %0, [%1, %2] */
13694 #line 338 "rx-decode.opc"
13695                       int sz AU = (op[1] >> 4) & 0x03;
13696 #line 338 "rx-decode.opc"
13697                       int isrc AU = op[1] & 0x0f;
13698 #line 338 "rx-decode.opc"
13699                       int bsrc AU = (op[2] >> 4) & 0x0f;
13700 #line 338 "rx-decode.opc"
13701                       int rdst AU = op[2] & 0x0f;
13702                       if (trace)
13703                         {
13704                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13705                                  "/** 1111 1110 00sz isrc bsrc rdst     mov%s   %0, [%1, %2] */",
13706                                  op[0], op[1], op[2]);
13707                           printf ("  sz = 0x%x,", sz);
13708                           printf ("  isrc = 0x%x,", isrc);
13709                           printf ("  bsrc = 0x%x,", bsrc);
13710                           printf ("  rdst = 0x%x\n", rdst);
13711                         }
13712                       SYNTAX("mov%s     %0, [%1, %2]");
13713 #line 338 "rx-decode.opc"
13714                       ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13715
13716                     }
13717                   break;
13718               }
13719             break;
13720           case 0x01:
13721               GETBYTE ();
13722               switch (op[2] & 0x00)
13723               {
13724                 case 0x00:
13725                   goto op_semantics_115;
13726                   break;
13727               }
13728             break;
13729           case 0x02:
13730               GETBYTE ();
13731               switch (op[2] & 0x00)
13732               {
13733                 case 0x00:
13734                   goto op_semantics_115;
13735                   break;
13736               }
13737             break;
13738           case 0x03:
13739               GETBYTE ();
13740               switch (op[2] & 0x00)
13741               {
13742                 case 0x00:
13743                   goto op_semantics_115;
13744                   break;
13745               }
13746             break;
13747           case 0x04:
13748               GETBYTE ();
13749               switch (op[2] & 0x00)
13750               {
13751                 case 0x00:
13752                   goto op_semantics_115;
13753                   break;
13754               }
13755             break;
13756           case 0x05:
13757               GETBYTE ();
13758               switch (op[2] & 0x00)
13759               {
13760                 case 0x00:
13761                   goto op_semantics_115;
13762                   break;
13763               }
13764             break;
13765           case 0x06:
13766               GETBYTE ();
13767               switch (op[2] & 0x00)
13768               {
13769                 case 0x00:
13770                   goto op_semantics_115;
13771                   break;
13772               }
13773             break;
13774           case 0x07:
13775               GETBYTE ();
13776               switch (op[2] & 0x00)
13777               {
13778                 case 0x00:
13779                   goto op_semantics_115;
13780                   break;
13781               }
13782             break;
13783           case 0x08:
13784               GETBYTE ();
13785               switch (op[2] & 0x00)
13786               {
13787                 case 0x00:
13788                   goto op_semantics_115;
13789                   break;
13790               }
13791             break;
13792           case 0x09:
13793               GETBYTE ();
13794               switch (op[2] & 0x00)
13795               {
13796                 case 0x00:
13797                   goto op_semantics_115;
13798                   break;
13799               }
13800             break;
13801           case 0x0a:
13802               GETBYTE ();
13803               switch (op[2] & 0x00)
13804               {
13805                 case 0x00:
13806                   goto op_semantics_115;
13807                   break;
13808               }
13809             break;
13810           case 0x0b:
13811               GETBYTE ();
13812               switch (op[2] & 0x00)
13813               {
13814                 case 0x00:
13815                   goto op_semantics_115;
13816                   break;
13817               }
13818             break;
13819           case 0x0c:
13820               GETBYTE ();
13821               switch (op[2] & 0x00)
13822               {
13823                 case 0x00:
13824                   goto op_semantics_115;
13825                   break;
13826               }
13827             break;
13828           case 0x0d:
13829               GETBYTE ();
13830               switch (op[2] & 0x00)
13831               {
13832                 case 0x00:
13833                   goto op_semantics_115;
13834                   break;
13835               }
13836             break;
13837           case 0x0e:
13838               GETBYTE ();
13839               switch (op[2] & 0x00)
13840               {
13841                 case 0x00:
13842                   goto op_semantics_115;
13843                   break;
13844               }
13845             break;
13846           case 0x0f:
13847               GETBYTE ();
13848               switch (op[2] & 0x00)
13849               {
13850                 case 0x00:
13851                   goto op_semantics_115;
13852                   break;
13853               }
13854             break;
13855           case 0x10:
13856               GETBYTE ();
13857               switch (op[2] & 0x00)
13858               {
13859                 case 0x00:
13860                   goto op_semantics_115;
13861                   break;
13862               }
13863             break;
13864           case 0x11:
13865               GETBYTE ();
13866               switch (op[2] & 0x00)
13867               {
13868                 case 0x00:
13869                   goto op_semantics_115;
13870                   break;
13871               }
13872             break;
13873           case 0x12:
13874               GETBYTE ();
13875               switch (op[2] & 0x00)
13876               {
13877                 case 0x00:
13878                   goto op_semantics_115;
13879                   break;
13880               }
13881             break;
13882           case 0x13:
13883               GETBYTE ();
13884               switch (op[2] & 0x00)
13885               {
13886                 case 0x00:
13887                   goto op_semantics_115;
13888                   break;
13889               }
13890             break;
13891           case 0x14:
13892               GETBYTE ();
13893               switch (op[2] & 0x00)
13894               {
13895                 case 0x00:
13896                   goto op_semantics_115;
13897                   break;
13898               }
13899             break;
13900           case 0x15:
13901               GETBYTE ();
13902               switch (op[2] & 0x00)
13903               {
13904                 case 0x00:
13905                   goto op_semantics_115;
13906                   break;
13907               }
13908             break;
13909           case 0x16:
13910               GETBYTE ();
13911               switch (op[2] & 0x00)
13912               {
13913                 case 0x00:
13914                   goto op_semantics_115;
13915                   break;
13916               }
13917             break;
13918           case 0x17:
13919               GETBYTE ();
13920               switch (op[2] & 0x00)
13921               {
13922                 case 0x00:
13923                   goto op_semantics_115;
13924                   break;
13925               }
13926             break;
13927           case 0x18:
13928               GETBYTE ();
13929               switch (op[2] & 0x00)
13930               {
13931                 case 0x00:
13932                   goto op_semantics_115;
13933                   break;
13934               }
13935             break;
13936           case 0x19:
13937               GETBYTE ();
13938               switch (op[2] & 0x00)
13939               {
13940                 case 0x00:
13941                   goto op_semantics_115;
13942                   break;
13943               }
13944             break;
13945           case 0x1a:
13946               GETBYTE ();
13947               switch (op[2] & 0x00)
13948               {
13949                 case 0x00:
13950                   goto op_semantics_115;
13951                   break;
13952               }
13953             break;
13954           case 0x1b:
13955               GETBYTE ();
13956               switch (op[2] & 0x00)
13957               {
13958                 case 0x00:
13959                   goto op_semantics_115;
13960                   break;
13961               }
13962             break;
13963           case 0x1c:
13964               GETBYTE ();
13965               switch (op[2] & 0x00)
13966               {
13967                 case 0x00:
13968                   goto op_semantics_115;
13969                   break;
13970               }
13971             break;
13972           case 0x1d:
13973               GETBYTE ();
13974               switch (op[2] & 0x00)
13975               {
13976                 case 0x00:
13977                   goto op_semantics_115;
13978                   break;
13979               }
13980             break;
13981           case 0x1e:
13982               GETBYTE ();
13983               switch (op[2] & 0x00)
13984               {
13985                 case 0x00:
13986                   goto op_semantics_115;
13987                   break;
13988               }
13989             break;
13990           case 0x1f:
13991               GETBYTE ();
13992               switch (op[2] & 0x00)
13993               {
13994                 case 0x00:
13995                   goto op_semantics_115;
13996                   break;
13997               }
13998             break;
13999           case 0x20:
14000               GETBYTE ();
14001               switch (op[2] & 0x00)
14002               {
14003                 case 0x00:
14004                   goto op_semantics_115;
14005                   break;
14006               }
14007             break;
14008           case 0x21:
14009               GETBYTE ();
14010               switch (op[2] & 0x00)
14011               {
14012                 case 0x00:
14013                   goto op_semantics_115;
14014                   break;
14015               }
14016             break;
14017           case 0x22:
14018               GETBYTE ();
14019               switch (op[2] & 0x00)
14020               {
14021                 case 0x00:
14022                   goto op_semantics_115;
14023                   break;
14024               }
14025             break;
14026           case 0x23:
14027               GETBYTE ();
14028               switch (op[2] & 0x00)
14029               {
14030                 case 0x00:
14031                   goto op_semantics_115;
14032                   break;
14033               }
14034             break;
14035           case 0x24:
14036               GETBYTE ();
14037               switch (op[2] & 0x00)
14038               {
14039                 case 0x00:
14040                   goto op_semantics_115;
14041                   break;
14042               }
14043             break;
14044           case 0x25:
14045               GETBYTE ();
14046               switch (op[2] & 0x00)
14047               {
14048                 case 0x00:
14049                   goto op_semantics_115;
14050                   break;
14051               }
14052             break;
14053           case 0x26:
14054               GETBYTE ();
14055               switch (op[2] & 0x00)
14056               {
14057                 case 0x00:
14058                   goto op_semantics_115;
14059                   break;
14060               }
14061             break;
14062           case 0x27:
14063               GETBYTE ();
14064               switch (op[2] & 0x00)
14065               {
14066                 case 0x00:
14067                   goto op_semantics_115;
14068                   break;
14069               }
14070             break;
14071           case 0x28:
14072               GETBYTE ();
14073               switch (op[2] & 0x00)
14074               {
14075                 case 0x00:
14076                   goto op_semantics_115;
14077                   break;
14078               }
14079             break;
14080           case 0x29:
14081               GETBYTE ();
14082               switch (op[2] & 0x00)
14083               {
14084                 case 0x00:
14085                   goto op_semantics_115;
14086                   break;
14087               }
14088             break;
14089           case 0x2a:
14090               GETBYTE ();
14091               switch (op[2] & 0x00)
14092               {
14093                 case 0x00:
14094                   goto op_semantics_115;
14095                   break;
14096               }
14097             break;
14098           case 0x2b:
14099               GETBYTE ();
14100               switch (op[2] & 0x00)
14101               {
14102                 case 0x00:
14103                   goto op_semantics_115;
14104                   break;
14105               }
14106             break;
14107           case 0x2c:
14108               GETBYTE ();
14109               switch (op[2] & 0x00)
14110               {
14111                 case 0x00:
14112                   goto op_semantics_115;
14113                   break;
14114               }
14115             break;
14116           case 0x2d:
14117               GETBYTE ();
14118               switch (op[2] & 0x00)
14119               {
14120                 case 0x00:
14121                   goto op_semantics_115;
14122                   break;
14123               }
14124             break;
14125           case 0x2e:
14126               GETBYTE ();
14127               switch (op[2] & 0x00)
14128               {
14129                 case 0x00:
14130                   goto op_semantics_115;
14131                   break;
14132               }
14133             break;
14134           case 0x2f:
14135               GETBYTE ();
14136               switch (op[2] & 0x00)
14137               {
14138                 case 0x00:
14139                   goto op_semantics_115;
14140                   break;
14141               }
14142             break;
14143           case 0x40:
14144               GETBYTE ();
14145               switch (op[2] & 0x00)
14146               {
14147                 case 0x00:
14148                   op_semantics_116:
14149                     {
14150                       /** 1111 1110 01sz isrc bsrc rdst mov%s   [%1, %2], %0 */
14151 #line 335 "rx-decode.opc"
14152                       int sz AU = (op[1] >> 4) & 0x03;
14153 #line 335 "rx-decode.opc"
14154                       int isrc AU = op[1] & 0x0f;
14155 #line 335 "rx-decode.opc"
14156                       int bsrc AU = (op[2] >> 4) & 0x0f;
14157 #line 335 "rx-decode.opc"
14158                       int rdst AU = op[2] & 0x0f;
14159                       if (trace)
14160                         {
14161                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14162                                  "/** 1111 1110 01sz isrc bsrc rdst     mov%s   [%1, %2], %0 */",
14163                                  op[0], op[1], op[2]);
14164                           printf ("  sz = 0x%x,", sz);
14165                           printf ("  isrc = 0x%x,", isrc);
14166                           printf ("  bsrc = 0x%x,", bsrc);
14167                           printf ("  rdst = 0x%x\n", rdst);
14168                         }
14169                       SYNTAX("mov%s     [%1, %2], %0");
14170 #line 335 "rx-decode.opc"
14171                       ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
14172
14173                     }
14174                   break;
14175               }
14176             break;
14177           case 0x41:
14178               GETBYTE ();
14179               switch (op[2] & 0x00)
14180               {
14181                 case 0x00:
14182                   goto op_semantics_116;
14183                   break;
14184               }
14185             break;
14186           case 0x42:
14187               GETBYTE ();
14188               switch (op[2] & 0x00)
14189               {
14190                 case 0x00:
14191                   goto op_semantics_116;
14192                   break;
14193               }
14194             break;
14195           case 0x43:
14196               GETBYTE ();
14197               switch (op[2] & 0x00)
14198               {
14199                 case 0x00:
14200                   goto op_semantics_116;
14201                   break;
14202               }
14203             break;
14204           case 0x44:
14205               GETBYTE ();
14206               switch (op[2] & 0x00)
14207               {
14208                 case 0x00:
14209                   goto op_semantics_116;
14210                   break;
14211               }
14212             break;
14213           case 0x45:
14214               GETBYTE ();
14215               switch (op[2] & 0x00)
14216               {
14217                 case 0x00:
14218                   goto op_semantics_116;
14219                   break;
14220               }
14221             break;
14222           case 0x46:
14223               GETBYTE ();
14224               switch (op[2] & 0x00)
14225               {
14226                 case 0x00:
14227                   goto op_semantics_116;
14228                   break;
14229               }
14230             break;
14231           case 0x47:
14232               GETBYTE ();
14233               switch (op[2] & 0x00)
14234               {
14235                 case 0x00:
14236                   goto op_semantics_116;
14237                   break;
14238               }
14239             break;
14240           case 0x48:
14241               GETBYTE ();
14242               switch (op[2] & 0x00)
14243               {
14244                 case 0x00:
14245                   goto op_semantics_116;
14246                   break;
14247               }
14248             break;
14249           case 0x49:
14250               GETBYTE ();
14251               switch (op[2] & 0x00)
14252               {
14253                 case 0x00:
14254                   goto op_semantics_116;
14255                   break;
14256               }
14257             break;
14258           case 0x4a:
14259               GETBYTE ();
14260               switch (op[2] & 0x00)
14261               {
14262                 case 0x00:
14263                   goto op_semantics_116;
14264                   break;
14265               }
14266             break;
14267           case 0x4b:
14268               GETBYTE ();
14269               switch (op[2] & 0x00)
14270               {
14271                 case 0x00:
14272                   goto op_semantics_116;
14273                   break;
14274               }
14275             break;
14276           case 0x4c:
14277               GETBYTE ();
14278               switch (op[2] & 0x00)
14279               {
14280                 case 0x00:
14281                   goto op_semantics_116;
14282                   break;
14283               }
14284             break;
14285           case 0x4d:
14286               GETBYTE ();
14287               switch (op[2] & 0x00)
14288               {
14289                 case 0x00:
14290                   goto op_semantics_116;
14291                   break;
14292               }
14293             break;
14294           case 0x4e:
14295               GETBYTE ();
14296               switch (op[2] & 0x00)
14297               {
14298                 case 0x00:
14299                   goto op_semantics_116;
14300                   break;
14301               }
14302             break;
14303           case 0x4f:
14304               GETBYTE ();
14305               switch (op[2] & 0x00)
14306               {
14307                 case 0x00:
14308                   goto op_semantics_116;
14309                   break;
14310               }
14311             break;
14312           case 0x50:
14313               GETBYTE ();
14314               switch (op[2] & 0x00)
14315               {
14316                 case 0x00:
14317                   goto op_semantics_116;
14318                   break;
14319               }
14320             break;
14321           case 0x51:
14322               GETBYTE ();
14323               switch (op[2] & 0x00)
14324               {
14325                 case 0x00:
14326                   goto op_semantics_116;
14327                   break;
14328               }
14329             break;
14330           case 0x52:
14331               GETBYTE ();
14332               switch (op[2] & 0x00)
14333               {
14334                 case 0x00:
14335                   goto op_semantics_116;
14336                   break;
14337               }
14338             break;
14339           case 0x53:
14340               GETBYTE ();
14341               switch (op[2] & 0x00)
14342               {
14343                 case 0x00:
14344                   goto op_semantics_116;
14345                   break;
14346               }
14347             break;
14348           case 0x54:
14349               GETBYTE ();
14350               switch (op[2] & 0x00)
14351               {
14352                 case 0x00:
14353                   goto op_semantics_116;
14354                   break;
14355               }
14356             break;
14357           case 0x55:
14358               GETBYTE ();
14359               switch (op[2] & 0x00)
14360               {
14361                 case 0x00:
14362                   goto op_semantics_116;
14363                   break;
14364               }
14365             break;
14366           case 0x56:
14367               GETBYTE ();
14368               switch (op[2] & 0x00)
14369               {
14370                 case 0x00:
14371                   goto op_semantics_116;
14372                   break;
14373               }
14374             break;
14375           case 0x57:
14376               GETBYTE ();
14377               switch (op[2] & 0x00)
14378               {
14379                 case 0x00:
14380                   goto op_semantics_116;
14381                   break;
14382               }
14383             break;
14384           case 0x58:
14385               GETBYTE ();
14386               switch (op[2] & 0x00)
14387               {
14388                 case 0x00:
14389                   goto op_semantics_116;
14390                   break;
14391               }
14392             break;
14393           case 0x59:
14394               GETBYTE ();
14395               switch (op[2] & 0x00)
14396               {
14397                 case 0x00:
14398                   goto op_semantics_116;
14399                   break;
14400               }
14401             break;
14402           case 0x5a:
14403               GETBYTE ();
14404               switch (op[2] & 0x00)
14405               {
14406                 case 0x00:
14407                   goto op_semantics_116;
14408                   break;
14409               }
14410             break;
14411           case 0x5b:
14412               GETBYTE ();
14413               switch (op[2] & 0x00)
14414               {
14415                 case 0x00:
14416                   goto op_semantics_116;
14417                   break;
14418               }
14419             break;
14420           case 0x5c:
14421               GETBYTE ();
14422               switch (op[2] & 0x00)
14423               {
14424                 case 0x00:
14425                   goto op_semantics_116;
14426                   break;
14427               }
14428             break;
14429           case 0x5d:
14430               GETBYTE ();
14431               switch (op[2] & 0x00)
14432               {
14433                 case 0x00:
14434                   goto op_semantics_116;
14435                   break;
14436               }
14437             break;
14438           case 0x5e:
14439               GETBYTE ();
14440               switch (op[2] & 0x00)
14441               {
14442                 case 0x00:
14443                   goto op_semantics_116;
14444                   break;
14445               }
14446             break;
14447           case 0x5f:
14448               GETBYTE ();
14449               switch (op[2] & 0x00)
14450               {
14451                 case 0x00:
14452                   goto op_semantics_116;
14453                   break;
14454               }
14455             break;
14456           case 0x60:
14457               GETBYTE ();
14458               switch (op[2] & 0x00)
14459               {
14460                 case 0x00:
14461                   goto op_semantics_116;
14462                   break;
14463               }
14464             break;
14465           case 0x61:
14466               GETBYTE ();
14467               switch (op[2] & 0x00)
14468               {
14469                 case 0x00:
14470                   goto op_semantics_116;
14471                   break;
14472               }
14473             break;
14474           case 0x62:
14475               GETBYTE ();
14476               switch (op[2] & 0x00)
14477               {
14478                 case 0x00:
14479                   goto op_semantics_116;
14480                   break;
14481               }
14482             break;
14483           case 0x63:
14484               GETBYTE ();
14485               switch (op[2] & 0x00)
14486               {
14487                 case 0x00:
14488                   goto op_semantics_116;
14489                   break;
14490               }
14491             break;
14492           case 0x64:
14493               GETBYTE ();
14494               switch (op[2] & 0x00)
14495               {
14496                 case 0x00:
14497                   goto op_semantics_116;
14498                   break;
14499               }
14500             break;
14501           case 0x65:
14502               GETBYTE ();
14503               switch (op[2] & 0x00)
14504               {
14505                 case 0x00:
14506                   goto op_semantics_116;
14507                   break;
14508               }
14509             break;
14510           case 0x66:
14511               GETBYTE ();
14512               switch (op[2] & 0x00)
14513               {
14514                 case 0x00:
14515                   goto op_semantics_116;
14516                   break;
14517               }
14518             break;
14519           case 0x67:
14520               GETBYTE ();
14521               switch (op[2] & 0x00)
14522               {
14523                 case 0x00:
14524                   goto op_semantics_116;
14525                   break;
14526               }
14527             break;
14528           case 0x68:
14529               GETBYTE ();
14530               switch (op[2] & 0x00)
14531               {
14532                 case 0x00:
14533                   goto op_semantics_116;
14534                   break;
14535               }
14536             break;
14537           case 0x69:
14538               GETBYTE ();
14539               switch (op[2] & 0x00)
14540               {
14541                 case 0x00:
14542                   goto op_semantics_116;
14543                   break;
14544               }
14545             break;
14546           case 0x6a:
14547               GETBYTE ();
14548               switch (op[2] & 0x00)
14549               {
14550                 case 0x00:
14551                   goto op_semantics_116;
14552                   break;
14553               }
14554             break;
14555           case 0x6b:
14556               GETBYTE ();
14557               switch (op[2] & 0x00)
14558               {
14559                 case 0x00:
14560                   goto op_semantics_116;
14561                   break;
14562               }
14563             break;
14564           case 0x6c:
14565               GETBYTE ();
14566               switch (op[2] & 0x00)
14567               {
14568                 case 0x00:
14569                   goto op_semantics_116;
14570                   break;
14571               }
14572             break;
14573           case 0x6d:
14574               GETBYTE ();
14575               switch (op[2] & 0x00)
14576               {
14577                 case 0x00:
14578                   goto op_semantics_116;
14579                   break;
14580               }
14581             break;
14582           case 0x6e:
14583               GETBYTE ();
14584               switch (op[2] & 0x00)
14585               {
14586                 case 0x00:
14587                   goto op_semantics_116;
14588                   break;
14589               }
14590             break;
14591           case 0x6f:
14592               GETBYTE ();
14593               switch (op[2] & 0x00)
14594               {
14595                 case 0x00:
14596                   goto op_semantics_116;
14597                   break;
14598               }
14599             break;
14600           case 0xc0:
14601               GETBYTE ();
14602               switch (op[2] & 0x00)
14603               {
14604                 case 0x00:
14605                   op_semantics_117:
14606                     {
14607                       /** 1111 1110 11sz isrc bsrc rdst movu%s  [%1, %2], %0 */
14608 #line 341 "rx-decode.opc"
14609                       int sz AU = (op[1] >> 4) & 0x03;
14610 #line 341 "rx-decode.opc"
14611                       int isrc AU = op[1] & 0x0f;
14612 #line 341 "rx-decode.opc"
14613                       int bsrc AU = (op[2] >> 4) & 0x0f;
14614 #line 341 "rx-decode.opc"
14615                       int rdst AU = op[2] & 0x0f;
14616                       if (trace)
14617                         {
14618                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14619                                  "/** 1111 1110 11sz isrc bsrc rdst     movu%s  [%1, %2], %0 */",
14620                                  op[0], op[1], op[2]);
14621                           printf ("  sz = 0x%x,", sz);
14622                           printf ("  isrc = 0x%x,", isrc);
14623                           printf ("  bsrc = 0x%x,", bsrc);
14624                           printf ("  rdst = 0x%x\n", rdst);
14625                         }
14626                       SYNTAX("movu%s    [%1, %2], %0");
14627 #line 341 "rx-decode.opc"
14628                       ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
14629
14630                     }
14631                   break;
14632               }
14633             break;
14634           case 0xc1:
14635               GETBYTE ();
14636               switch (op[2] & 0x00)
14637               {
14638                 case 0x00:
14639                   goto op_semantics_117;
14640                   break;
14641               }
14642             break;
14643           case 0xc2:
14644               GETBYTE ();
14645               switch (op[2] & 0x00)
14646               {
14647                 case 0x00:
14648                   goto op_semantics_117;
14649                   break;
14650               }
14651             break;
14652           case 0xc3:
14653               GETBYTE ();
14654               switch (op[2] & 0x00)
14655               {
14656                 case 0x00:
14657                   goto op_semantics_117;
14658                   break;
14659               }
14660             break;
14661           case 0xc4:
14662               GETBYTE ();
14663               switch (op[2] & 0x00)
14664               {
14665                 case 0x00:
14666                   goto op_semantics_117;
14667                   break;
14668               }
14669             break;
14670           case 0xc5:
14671               GETBYTE ();
14672               switch (op[2] & 0x00)
14673               {
14674                 case 0x00:
14675                   goto op_semantics_117;
14676                   break;
14677               }
14678             break;
14679           case 0xc6:
14680               GETBYTE ();
14681               switch (op[2] & 0x00)
14682               {
14683                 case 0x00:
14684                   goto op_semantics_117;
14685                   break;
14686               }
14687             break;
14688           case 0xc7:
14689               GETBYTE ();
14690               switch (op[2] & 0x00)
14691               {
14692                 case 0x00:
14693                   goto op_semantics_117;
14694                   break;
14695               }
14696             break;
14697           case 0xc8:
14698               GETBYTE ();
14699               switch (op[2] & 0x00)
14700               {
14701                 case 0x00:
14702                   goto op_semantics_117;
14703                   break;
14704               }
14705             break;
14706           case 0xc9:
14707               GETBYTE ();
14708               switch (op[2] & 0x00)
14709               {
14710                 case 0x00:
14711                   goto op_semantics_117;
14712                   break;
14713               }
14714             break;
14715           case 0xca:
14716               GETBYTE ();
14717               switch (op[2] & 0x00)
14718               {
14719                 case 0x00:
14720                   goto op_semantics_117;
14721                   break;
14722               }
14723             break;
14724           case 0xcb:
14725               GETBYTE ();
14726               switch (op[2] & 0x00)
14727               {
14728                 case 0x00:
14729                   goto op_semantics_117;
14730                   break;
14731               }
14732             break;
14733           case 0xcc:
14734               GETBYTE ();
14735               switch (op[2] & 0x00)
14736               {
14737                 case 0x00:
14738                   goto op_semantics_117;
14739                   break;
14740               }
14741             break;
14742           case 0xcd:
14743               GETBYTE ();
14744               switch (op[2] & 0x00)
14745               {
14746                 case 0x00:
14747                   goto op_semantics_117;
14748                   break;
14749               }
14750             break;
14751           case 0xce:
14752               GETBYTE ();
14753               switch (op[2] & 0x00)
14754               {
14755                 case 0x00:
14756                   goto op_semantics_117;
14757                   break;
14758               }
14759             break;
14760           case 0xcf:
14761               GETBYTE ();
14762               switch (op[2] & 0x00)
14763               {
14764                 case 0x00:
14765                   goto op_semantics_117;
14766                   break;
14767               }
14768             break;
14769           case 0xd0:
14770               GETBYTE ();
14771               switch (op[2] & 0x00)
14772               {
14773                 case 0x00:
14774                   goto op_semantics_117;
14775                   break;
14776               }
14777             break;
14778           case 0xd1:
14779               GETBYTE ();
14780               switch (op[2] & 0x00)
14781               {
14782                 case 0x00:
14783                   goto op_semantics_117;
14784                   break;
14785               }
14786             break;
14787           case 0xd2:
14788               GETBYTE ();
14789               switch (op[2] & 0x00)
14790               {
14791                 case 0x00:
14792                   goto op_semantics_117;
14793                   break;
14794               }
14795             break;
14796           case 0xd3:
14797               GETBYTE ();
14798               switch (op[2] & 0x00)
14799               {
14800                 case 0x00:
14801                   goto op_semantics_117;
14802                   break;
14803               }
14804             break;
14805           case 0xd4:
14806               GETBYTE ();
14807               switch (op[2] & 0x00)
14808               {
14809                 case 0x00:
14810                   goto op_semantics_117;
14811                   break;
14812               }
14813             break;
14814           case 0xd5:
14815               GETBYTE ();
14816               switch (op[2] & 0x00)
14817               {
14818                 case 0x00:
14819                   goto op_semantics_117;
14820                   break;
14821               }
14822             break;
14823           case 0xd6:
14824               GETBYTE ();
14825               switch (op[2] & 0x00)
14826               {
14827                 case 0x00:
14828                   goto op_semantics_117;
14829                   break;
14830               }
14831             break;
14832           case 0xd7:
14833               GETBYTE ();
14834               switch (op[2] & 0x00)
14835               {
14836                 case 0x00:
14837                   goto op_semantics_117;
14838                   break;
14839               }
14840             break;
14841           case 0xd8:
14842               GETBYTE ();
14843               switch (op[2] & 0x00)
14844               {
14845                 case 0x00:
14846                   goto op_semantics_117;
14847                   break;
14848               }
14849             break;
14850           case 0xd9:
14851               GETBYTE ();
14852               switch (op[2] & 0x00)
14853               {
14854                 case 0x00:
14855                   goto op_semantics_117;
14856                   break;
14857               }
14858             break;
14859           case 0xda:
14860               GETBYTE ();
14861               switch (op[2] & 0x00)
14862               {
14863                 case 0x00:
14864                   goto op_semantics_117;
14865                   break;
14866               }
14867             break;
14868           case 0xdb:
14869               GETBYTE ();
14870               switch (op[2] & 0x00)
14871               {
14872                 case 0x00:
14873                   goto op_semantics_117;
14874                   break;
14875               }
14876             break;
14877           case 0xdc:
14878               GETBYTE ();
14879               switch (op[2] & 0x00)
14880               {
14881                 case 0x00:
14882                   goto op_semantics_117;
14883                   break;
14884               }
14885             break;
14886           case 0xdd:
14887               GETBYTE ();
14888               switch (op[2] & 0x00)
14889               {
14890                 case 0x00:
14891                   goto op_semantics_117;
14892                   break;
14893               }
14894             break;
14895           case 0xde:
14896               GETBYTE ();
14897               switch (op[2] & 0x00)
14898               {
14899                 case 0x00:
14900                   goto op_semantics_117;
14901                   break;
14902               }
14903             break;
14904           case 0xdf:
14905               GETBYTE ();
14906               switch (op[2] & 0x00)
14907               {
14908                 case 0x00:
14909                   goto op_semantics_117;
14910                   break;
14911               }
14912             break;
14913           case 0xe0:
14914               GETBYTE ();
14915               switch (op[2] & 0x00)
14916               {
14917                 case 0x00:
14918                   goto op_semantics_117;
14919                   break;
14920               }
14921             break;
14922           case 0xe1:
14923               GETBYTE ();
14924               switch (op[2] & 0x00)
14925               {
14926                 case 0x00:
14927                   goto op_semantics_117;
14928                   break;
14929               }
14930             break;
14931           case 0xe2:
14932               GETBYTE ();
14933               switch (op[2] & 0x00)
14934               {
14935                 case 0x00:
14936                   goto op_semantics_117;
14937                   break;
14938               }
14939             break;
14940           case 0xe3:
14941               GETBYTE ();
14942               switch (op[2] & 0x00)
14943               {
14944                 case 0x00:
14945                   goto op_semantics_117;
14946                   break;
14947               }
14948             break;
14949           case 0xe4:
14950               GETBYTE ();
14951               switch (op[2] & 0x00)
14952               {
14953                 case 0x00:
14954                   goto op_semantics_117;
14955                   break;
14956               }
14957             break;
14958           case 0xe5:
14959               GETBYTE ();
14960               switch (op[2] & 0x00)
14961               {
14962                 case 0x00:
14963                   goto op_semantics_117;
14964                   break;
14965               }
14966             break;
14967           case 0xe6:
14968               GETBYTE ();
14969               switch (op[2] & 0x00)
14970               {
14971                 case 0x00:
14972                   goto op_semantics_117;
14973                   break;
14974               }
14975             break;
14976           case 0xe7:
14977               GETBYTE ();
14978               switch (op[2] & 0x00)
14979               {
14980                 case 0x00:
14981                   goto op_semantics_117;
14982                   break;
14983               }
14984             break;
14985           case 0xe8:
14986               GETBYTE ();
14987               switch (op[2] & 0x00)
14988               {
14989                 case 0x00:
14990                   goto op_semantics_117;
14991                   break;
14992               }
14993             break;
14994           case 0xe9:
14995               GETBYTE ();
14996               switch (op[2] & 0x00)
14997               {
14998                 case 0x00:
14999                   goto op_semantics_117;
15000                   break;
15001               }
15002             break;
15003           case 0xea:
15004               GETBYTE ();
15005               switch (op[2] & 0x00)
15006               {
15007                 case 0x00:
15008                   goto op_semantics_117;
15009                   break;
15010               }
15011             break;
15012           case 0xeb:
15013               GETBYTE ();
15014               switch (op[2] & 0x00)
15015               {
15016                 case 0x00:
15017                   goto op_semantics_117;
15018                   break;
15019               }
15020             break;
15021           case 0xec:
15022               GETBYTE ();
15023               switch (op[2] & 0x00)
15024               {
15025                 case 0x00:
15026                   goto op_semantics_117;
15027                   break;
15028               }
15029             break;
15030           case 0xed:
15031               GETBYTE ();
15032               switch (op[2] & 0x00)
15033               {
15034                 case 0x00:
15035                   goto op_semantics_117;
15036                   break;
15037               }
15038             break;
15039           case 0xee:
15040               GETBYTE ();
15041               switch (op[2] & 0x00)
15042               {
15043                 case 0x00:
15044                   goto op_semantics_117;
15045                   break;
15046               }
15047             break;
15048           case 0xef:
15049               GETBYTE ();
15050               switch (op[2] & 0x00)
15051               {
15052                 case 0x00:
15053                   goto op_semantics_117;
15054                   break;
15055               }
15056             break;
15057           default: UNSUPPORTED(); break;
15058         }
15059       break;
15060     case 0xff:
15061         GETBYTE ();
15062         switch (op[1] & 0xff)
15063         {
15064           case 0x00:
15065               GETBYTE ();
15066               switch (op[2] & 0x00)
15067               {
15068                 case 0x00:
15069                   op_semantics_118:
15070                     {
15071                       /** 1111 1111 0000 rdst srca srcb sub     %2, %1, %0 */
15072 #line 545 "rx-decode.opc"
15073                       int rdst AU = op[1] & 0x0f;
15074 #line 545 "rx-decode.opc"
15075                       int srca AU = (op[2] >> 4) & 0x0f;
15076 #line 545 "rx-decode.opc"
15077                       int srcb AU = op[2] & 0x0f;
15078                       if (trace)
15079                         {
15080                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15081                                  "/** 1111 1111 0000 rdst srca srcb     sub     %2, %1, %0 */",
15082                                  op[0], op[1], op[2]);
15083                           printf ("  rdst = 0x%x,", rdst);
15084                           printf ("  srca = 0x%x,", srca);
15085                           printf ("  srcb = 0x%x\n", srcb);
15086                         }
15087                       SYNTAX("sub       %2, %1, %0");
15088 #line 545 "rx-decode.opc"
15089                       ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15090
15091                     /*----------------------------------------------------------------------*/
15092                     /* SBB                                                                      */
15093
15094                     }
15095                   break;
15096               }
15097             break;
15098           case 0x01:
15099               GETBYTE ();
15100               switch (op[2] & 0x00)
15101               {
15102                 case 0x00:
15103                   goto op_semantics_118;
15104                   break;
15105               }
15106             break;
15107           case 0x02:
15108               GETBYTE ();
15109               switch (op[2] & 0x00)
15110               {
15111                 case 0x00:
15112                   goto op_semantics_118;
15113                   break;
15114               }
15115             break;
15116           case 0x03:
15117               GETBYTE ();
15118               switch (op[2] & 0x00)
15119               {
15120                 case 0x00:
15121                   goto op_semantics_118;
15122                   break;
15123               }
15124             break;
15125           case 0x04:
15126               GETBYTE ();
15127               switch (op[2] & 0x00)
15128               {
15129                 case 0x00:
15130                   goto op_semantics_118;
15131                   break;
15132               }
15133             break;
15134           case 0x05:
15135               GETBYTE ();
15136               switch (op[2] & 0x00)
15137               {
15138                 case 0x00:
15139                   goto op_semantics_118;
15140                   break;
15141               }
15142             break;
15143           case 0x06:
15144               GETBYTE ();
15145               switch (op[2] & 0x00)
15146               {
15147                 case 0x00:
15148                   goto op_semantics_118;
15149                   break;
15150               }
15151             break;
15152           case 0x07:
15153               GETBYTE ();
15154               switch (op[2] & 0x00)
15155               {
15156                 case 0x00:
15157                   goto op_semantics_118;
15158                   break;
15159               }
15160             break;
15161           case 0x08:
15162               GETBYTE ();
15163               switch (op[2] & 0x00)
15164               {
15165                 case 0x00:
15166                   goto op_semantics_118;
15167                   break;
15168               }
15169             break;
15170           case 0x09:
15171               GETBYTE ();
15172               switch (op[2] & 0x00)
15173               {
15174                 case 0x00:
15175                   goto op_semantics_118;
15176                   break;
15177               }
15178             break;
15179           case 0x0a:
15180               GETBYTE ();
15181               switch (op[2] & 0x00)
15182               {
15183                 case 0x00:
15184                   goto op_semantics_118;
15185                   break;
15186               }
15187             break;
15188           case 0x0b:
15189               GETBYTE ();
15190               switch (op[2] & 0x00)
15191               {
15192                 case 0x00:
15193                   goto op_semantics_118;
15194                   break;
15195               }
15196             break;
15197           case 0x0c:
15198               GETBYTE ();
15199               switch (op[2] & 0x00)
15200               {
15201                 case 0x00:
15202                   goto op_semantics_118;
15203                   break;
15204               }
15205             break;
15206           case 0x0d:
15207               GETBYTE ();
15208               switch (op[2] & 0x00)
15209               {
15210                 case 0x00:
15211                   goto op_semantics_118;
15212                   break;
15213               }
15214             break;
15215           case 0x0e:
15216               GETBYTE ();
15217               switch (op[2] & 0x00)
15218               {
15219                 case 0x00:
15220                   goto op_semantics_118;
15221                   break;
15222               }
15223             break;
15224           case 0x0f:
15225               GETBYTE ();
15226               switch (op[2] & 0x00)
15227               {
15228                 case 0x00:
15229                   goto op_semantics_118;
15230                   break;
15231               }
15232             break;
15233           case 0x20:
15234               GETBYTE ();
15235               switch (op[2] & 0x00)
15236               {
15237                 case 0x00:
15238                   op_semantics_119:
15239                     {
15240                       /** 1111 1111 0010 rdst srca srcb add     %2, %1, %0 */
15241 #line 512 "rx-decode.opc"
15242                       int rdst AU = op[1] & 0x0f;
15243 #line 512 "rx-decode.opc"
15244                       int srca AU = (op[2] >> 4) & 0x0f;
15245 #line 512 "rx-decode.opc"
15246                       int srcb AU = op[2] & 0x0f;
15247                       if (trace)
15248                         {
15249                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15250                                  "/** 1111 1111 0010 rdst srca srcb     add     %2, %1, %0 */",
15251                                  op[0], op[1], op[2]);
15252                           printf ("  rdst = 0x%x,", rdst);
15253                           printf ("  srca = 0x%x,", srca);
15254                           printf ("  srcb = 0x%x\n", srcb);
15255                         }
15256                       SYNTAX("add       %2, %1, %0");
15257 #line 512 "rx-decode.opc"
15258                       ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
15259
15260                     /*----------------------------------------------------------------------*/
15261                     /* CMP                                                                      */
15262
15263                     }
15264                   break;
15265               }
15266             break;
15267           case 0x21:
15268               GETBYTE ();
15269               switch (op[2] & 0x00)
15270               {
15271                 case 0x00:
15272                   goto op_semantics_119;
15273                   break;
15274               }
15275             break;
15276           case 0x22:
15277               GETBYTE ();
15278               switch (op[2] & 0x00)
15279               {
15280                 case 0x00:
15281                   goto op_semantics_119;
15282                   break;
15283               }
15284             break;
15285           case 0x23:
15286               GETBYTE ();
15287               switch (op[2] & 0x00)
15288               {
15289                 case 0x00:
15290                   goto op_semantics_119;
15291                   break;
15292               }
15293             break;
15294           case 0x24:
15295               GETBYTE ();
15296               switch (op[2] & 0x00)
15297               {
15298                 case 0x00:
15299                   goto op_semantics_119;
15300                   break;
15301               }
15302             break;
15303           case 0x25:
15304               GETBYTE ();
15305               switch (op[2] & 0x00)
15306               {
15307                 case 0x00:
15308                   goto op_semantics_119;
15309                   break;
15310               }
15311             break;
15312           case 0x26:
15313               GETBYTE ();
15314               switch (op[2] & 0x00)
15315               {
15316                 case 0x00:
15317                   goto op_semantics_119;
15318                   break;
15319               }
15320             break;
15321           case 0x27:
15322               GETBYTE ();
15323               switch (op[2] & 0x00)
15324               {
15325                 case 0x00:
15326                   goto op_semantics_119;
15327                   break;
15328               }
15329             break;
15330           case 0x28:
15331               GETBYTE ();
15332               switch (op[2] & 0x00)
15333               {
15334                 case 0x00:
15335                   goto op_semantics_119;
15336                   break;
15337               }
15338             break;
15339           case 0x29:
15340               GETBYTE ();
15341               switch (op[2] & 0x00)
15342               {
15343                 case 0x00:
15344                   goto op_semantics_119;
15345                   break;
15346               }
15347             break;
15348           case 0x2a:
15349               GETBYTE ();
15350               switch (op[2] & 0x00)
15351               {
15352                 case 0x00:
15353                   goto op_semantics_119;
15354                   break;
15355               }
15356             break;
15357           case 0x2b:
15358               GETBYTE ();
15359               switch (op[2] & 0x00)
15360               {
15361                 case 0x00:
15362                   goto op_semantics_119;
15363                   break;
15364               }
15365             break;
15366           case 0x2c:
15367               GETBYTE ();
15368               switch (op[2] & 0x00)
15369               {
15370                 case 0x00:
15371                   goto op_semantics_119;
15372                   break;
15373               }
15374             break;
15375           case 0x2d:
15376               GETBYTE ();
15377               switch (op[2] & 0x00)
15378               {
15379                 case 0x00:
15380                   goto op_semantics_119;
15381                   break;
15382               }
15383             break;
15384           case 0x2e:
15385               GETBYTE ();
15386               switch (op[2] & 0x00)
15387               {
15388                 case 0x00:
15389                   goto op_semantics_119;
15390                   break;
15391               }
15392             break;
15393           case 0x2f:
15394               GETBYTE ();
15395               switch (op[2] & 0x00)
15396               {
15397                 case 0x00:
15398                   goto op_semantics_119;
15399                   break;
15400               }
15401             break;
15402           case 0x30:
15403               GETBYTE ();
15404               switch (op[2] & 0x00)
15405               {
15406                 case 0x00:
15407                   op_semantics_120:
15408                     {
15409                       /** 1111 1111 0011 rdst srca srcb mul     %2, %1, %0 */
15410 #line 652 "rx-decode.opc"
15411                       int rdst AU = op[1] & 0x0f;
15412 #line 652 "rx-decode.opc"
15413                       int srca AU = (op[2] >> 4) & 0x0f;
15414 #line 652 "rx-decode.opc"
15415                       int srcb AU = op[2] & 0x0f;
15416                       if (trace)
15417                         {
15418                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15419                                  "/** 1111 1111 0011 rdst srca srcb     mul     %2, %1, %0 */",
15420                                  op[0], op[1], op[2]);
15421                           printf ("  rdst = 0x%x,", rdst);
15422                           printf ("  srca = 0x%x,", srca);
15423                           printf ("  srcb = 0x%x\n", srcb);
15424                         }
15425                       SYNTAX("mul       %2, %1, %0");
15426 #line 652 "rx-decode.opc"
15427                       ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
15428
15429                     /*----------------------------------------------------------------------*/
15430                     /* EMUL                                                                     */
15431
15432                     }
15433                   break;
15434               }
15435             break;
15436           case 0x31:
15437               GETBYTE ();
15438               switch (op[2] & 0x00)
15439               {
15440                 case 0x00:
15441                   goto op_semantics_120;
15442                   break;
15443               }
15444             break;
15445           case 0x32:
15446               GETBYTE ();
15447               switch (op[2] & 0x00)
15448               {
15449                 case 0x00:
15450                   goto op_semantics_120;
15451                   break;
15452               }
15453             break;
15454           case 0x33:
15455               GETBYTE ();
15456               switch (op[2] & 0x00)
15457               {
15458                 case 0x00:
15459                   goto op_semantics_120;
15460                   break;
15461               }
15462             break;
15463           case 0x34:
15464               GETBYTE ();
15465               switch (op[2] & 0x00)
15466               {
15467                 case 0x00:
15468                   goto op_semantics_120;
15469                   break;
15470               }
15471             break;
15472           case 0x35:
15473               GETBYTE ();
15474               switch (op[2] & 0x00)
15475               {
15476                 case 0x00:
15477                   goto op_semantics_120;
15478                   break;
15479               }
15480             break;
15481           case 0x36:
15482               GETBYTE ();
15483               switch (op[2] & 0x00)
15484               {
15485                 case 0x00:
15486                   goto op_semantics_120;
15487                   break;
15488               }
15489             break;
15490           case 0x37:
15491               GETBYTE ();
15492               switch (op[2] & 0x00)
15493               {
15494                 case 0x00:
15495                   goto op_semantics_120;
15496                   break;
15497               }
15498             break;
15499           case 0x38:
15500               GETBYTE ();
15501               switch (op[2] & 0x00)
15502               {
15503                 case 0x00:
15504                   goto op_semantics_120;
15505                   break;
15506               }
15507             break;
15508           case 0x39:
15509               GETBYTE ();
15510               switch (op[2] & 0x00)
15511               {
15512                 case 0x00:
15513                   goto op_semantics_120;
15514                   break;
15515               }
15516             break;
15517           case 0x3a:
15518               GETBYTE ();
15519               switch (op[2] & 0x00)
15520               {
15521                 case 0x00:
15522                   goto op_semantics_120;
15523                   break;
15524               }
15525             break;
15526           case 0x3b:
15527               GETBYTE ();
15528               switch (op[2] & 0x00)
15529               {
15530                 case 0x00:
15531                   goto op_semantics_120;
15532                   break;
15533               }
15534             break;
15535           case 0x3c:
15536               GETBYTE ();
15537               switch (op[2] & 0x00)
15538               {
15539                 case 0x00:
15540                   goto op_semantics_120;
15541                   break;
15542               }
15543             break;
15544           case 0x3d:
15545               GETBYTE ();
15546               switch (op[2] & 0x00)
15547               {
15548                 case 0x00:
15549                   goto op_semantics_120;
15550                   break;
15551               }
15552             break;
15553           case 0x3e:
15554               GETBYTE ();
15555               switch (op[2] & 0x00)
15556               {
15557                 case 0x00:
15558                   goto op_semantics_120;
15559                   break;
15560               }
15561             break;
15562           case 0x3f:
15563               GETBYTE ();
15564               switch (op[2] & 0x00)
15565               {
15566                 case 0x00:
15567                   goto op_semantics_120;
15568                   break;
15569               }
15570             break;
15571           case 0x40:
15572               GETBYTE ();
15573               switch (op[2] & 0x00)
15574               {
15575                 case 0x00:
15576                   op_semantics_121:
15577                     {
15578                       /** 1111 1111 0100 rdst srca srcb and     %2, %1, %0 */
15579 #line 422 "rx-decode.opc"
15580                       int rdst AU = op[1] & 0x0f;
15581 #line 422 "rx-decode.opc"
15582                       int srca AU = (op[2] >> 4) & 0x0f;
15583 #line 422 "rx-decode.opc"
15584                       int srcb AU = op[2] & 0x0f;
15585                       if (trace)
15586                         {
15587                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15588                                  "/** 1111 1111 0100 rdst srca srcb     and     %2, %1, %0 */",
15589                                  op[0], op[1], op[2]);
15590                           printf ("  rdst = 0x%x,", rdst);
15591                           printf ("  srca = 0x%x,", srca);
15592                           printf ("  srcb = 0x%x\n", srcb);
15593                         }
15594                       SYNTAX("and       %2, %1, %0");
15595 #line 422 "rx-decode.opc"
15596                       ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15597
15598                     /*----------------------------------------------------------------------*/
15599                     /* OR                                                                       */
15600
15601                     }
15602                   break;
15603               }
15604             break;
15605           case 0x41:
15606               GETBYTE ();
15607               switch (op[2] & 0x00)
15608               {
15609                 case 0x00:
15610                   goto op_semantics_121;
15611                   break;
15612               }
15613             break;
15614           case 0x42:
15615               GETBYTE ();
15616               switch (op[2] & 0x00)
15617               {
15618                 case 0x00:
15619                   goto op_semantics_121;
15620                   break;
15621               }
15622             break;
15623           case 0x43:
15624               GETBYTE ();
15625               switch (op[2] & 0x00)
15626               {
15627                 case 0x00:
15628                   goto op_semantics_121;
15629                   break;
15630               }
15631             break;
15632           case 0x44:
15633               GETBYTE ();
15634               switch (op[2] & 0x00)
15635               {
15636                 case 0x00:
15637                   goto op_semantics_121;
15638                   break;
15639               }
15640             break;
15641           case 0x45:
15642               GETBYTE ();
15643               switch (op[2] & 0x00)
15644               {
15645                 case 0x00:
15646                   goto op_semantics_121;
15647                   break;
15648               }
15649             break;
15650           case 0x46:
15651               GETBYTE ();
15652               switch (op[2] & 0x00)
15653               {
15654                 case 0x00:
15655                   goto op_semantics_121;
15656                   break;
15657               }
15658             break;
15659           case 0x47:
15660               GETBYTE ();
15661               switch (op[2] & 0x00)
15662               {
15663                 case 0x00:
15664                   goto op_semantics_121;
15665                   break;
15666               }
15667             break;
15668           case 0x48:
15669               GETBYTE ();
15670               switch (op[2] & 0x00)
15671               {
15672                 case 0x00:
15673                   goto op_semantics_121;
15674                   break;
15675               }
15676             break;
15677           case 0x49:
15678               GETBYTE ();
15679               switch (op[2] & 0x00)
15680               {
15681                 case 0x00:
15682                   goto op_semantics_121;
15683                   break;
15684               }
15685             break;
15686           case 0x4a:
15687               GETBYTE ();
15688               switch (op[2] & 0x00)
15689               {
15690                 case 0x00:
15691                   goto op_semantics_121;
15692                   break;
15693               }
15694             break;
15695           case 0x4b:
15696               GETBYTE ();
15697               switch (op[2] & 0x00)
15698               {
15699                 case 0x00:
15700                   goto op_semantics_121;
15701                   break;
15702               }
15703             break;
15704           case 0x4c:
15705               GETBYTE ();
15706               switch (op[2] & 0x00)
15707               {
15708                 case 0x00:
15709                   goto op_semantics_121;
15710                   break;
15711               }
15712             break;
15713           case 0x4d:
15714               GETBYTE ();
15715               switch (op[2] & 0x00)
15716               {
15717                 case 0x00:
15718                   goto op_semantics_121;
15719                   break;
15720               }
15721             break;
15722           case 0x4e:
15723               GETBYTE ();
15724               switch (op[2] & 0x00)
15725               {
15726                 case 0x00:
15727                   goto op_semantics_121;
15728                   break;
15729               }
15730             break;
15731           case 0x4f:
15732               GETBYTE ();
15733               switch (op[2] & 0x00)
15734               {
15735                 case 0x00:
15736                   goto op_semantics_121;
15737                   break;
15738               }
15739             break;
15740           case 0x50:
15741               GETBYTE ();
15742               switch (op[2] & 0x00)
15743               {
15744                 case 0x00:
15745                   op_semantics_122:
15746                     {
15747                       /** 1111 1111 0101 rdst srca srcb or      %2, %1, %0 */
15748 #line 440 "rx-decode.opc"
15749                       int rdst AU = op[1] & 0x0f;
15750 #line 440 "rx-decode.opc"
15751                       int srca AU = (op[2] >> 4) & 0x0f;
15752 #line 440 "rx-decode.opc"
15753                       int srcb AU = op[2] & 0x0f;
15754                       if (trace)
15755                         {
15756                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15757                                  "/** 1111 1111 0101 rdst srca srcb     or      %2, %1, %0 */",
15758                                  op[0], op[1], op[2]);
15759                           printf ("  rdst = 0x%x,", rdst);
15760                           printf ("  srca = 0x%x,", srca);
15761                           printf ("  srcb = 0x%x\n", srcb);
15762                         }
15763                       SYNTAX("or        %2, %1, %0");
15764 #line 440 "rx-decode.opc"
15765                       ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15766
15767                     /*----------------------------------------------------------------------*/
15768                     /* XOR                                                                      */
15769
15770                     }
15771                   break;
15772               }
15773             break;
15774           case 0x51:
15775               GETBYTE ();
15776               switch (op[2] & 0x00)
15777               {
15778                 case 0x00:
15779                   goto op_semantics_122;
15780                   break;
15781               }
15782             break;
15783           case 0x52:
15784               GETBYTE ();
15785               switch (op[2] & 0x00)
15786               {
15787                 case 0x00:
15788                   goto op_semantics_122;
15789                   break;
15790               }
15791             break;
15792           case 0x53:
15793               GETBYTE ();
15794               switch (op[2] & 0x00)
15795               {
15796                 case 0x00:
15797                   goto op_semantics_122;
15798                   break;
15799               }
15800             break;
15801           case 0x54:
15802               GETBYTE ();
15803               switch (op[2] & 0x00)
15804               {
15805                 case 0x00:
15806                   goto op_semantics_122;
15807                   break;
15808               }
15809             break;
15810           case 0x55:
15811               GETBYTE ();
15812               switch (op[2] & 0x00)
15813               {
15814                 case 0x00:
15815                   goto op_semantics_122;
15816                   break;
15817               }
15818             break;
15819           case 0x56:
15820               GETBYTE ();
15821               switch (op[2] & 0x00)
15822               {
15823                 case 0x00:
15824                   goto op_semantics_122;
15825                   break;
15826               }
15827             break;
15828           case 0x57:
15829               GETBYTE ();
15830               switch (op[2] & 0x00)
15831               {
15832                 case 0x00:
15833                   goto op_semantics_122;
15834                   break;
15835               }
15836             break;
15837           case 0x58:
15838               GETBYTE ();
15839               switch (op[2] & 0x00)
15840               {
15841                 case 0x00:
15842                   goto op_semantics_122;
15843                   break;
15844               }
15845             break;
15846           case 0x59:
15847               GETBYTE ();
15848               switch (op[2] & 0x00)
15849               {
15850                 case 0x00:
15851                   goto op_semantics_122;
15852                   break;
15853               }
15854             break;
15855           case 0x5a:
15856               GETBYTE ();
15857               switch (op[2] & 0x00)
15858               {
15859                 case 0x00:
15860                   goto op_semantics_122;
15861                   break;
15862               }
15863             break;
15864           case 0x5b:
15865               GETBYTE ();
15866               switch (op[2] & 0x00)
15867               {
15868                 case 0x00:
15869                   goto op_semantics_122;
15870                   break;
15871               }
15872             break;
15873           case 0x5c:
15874               GETBYTE ();
15875               switch (op[2] & 0x00)
15876               {
15877                 case 0x00:
15878                   goto op_semantics_122;
15879                   break;
15880               }
15881             break;
15882           case 0x5d:
15883               GETBYTE ();
15884               switch (op[2] & 0x00)
15885               {
15886                 case 0x00:
15887                   goto op_semantics_122;
15888                   break;
15889               }
15890             break;
15891           case 0x5e:
15892               GETBYTE ();
15893               switch (op[2] & 0x00)
15894               {
15895                 case 0x00:
15896                   goto op_semantics_122;
15897                   break;
15898               }
15899             break;
15900           case 0x5f:
15901               GETBYTE ();
15902               switch (op[2] & 0x00)
15903               {
15904                 case 0x00:
15905                   goto op_semantics_122;
15906                   break;
15907               }
15908             break;
15909           case 0x80:
15910               GETBYTE ();
15911               switch (op[2] & 0x00)
15912               {
15913                 case 0x00:
15914                   op_semantics_123:
15915                     {
15916                       /** 1111 1111 1000 rdst srca srcb fsub    %2, %1, %0 */
15917 #line 1100 "rx-decode.opc"
15918                       int rdst AU = op[1] & 0x0f;
15919 #line 1100 "rx-decode.opc"
15920                       int srca AU = (op[2] >> 4) & 0x0f;
15921 #line 1100 "rx-decode.opc"
15922                       int srcb AU = op[2] & 0x0f;
15923                       if (trace)
15924                         {
15925                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15926                                  "/** 1111 1111 1000 rdst srca srcb     fsub    %2, %1, %0 */",
15927                                  op[0], op[1], op[2]);
15928                           printf ("  rdst = 0x%x,", rdst);
15929                           printf ("  srca = 0x%x,", srca);
15930                           printf ("  srcb = 0x%x\n", srcb);
15931                         }
15932                       SYNTAX("fsub      %2, %1, %0");
15933 #line 1100 "rx-decode.opc"
15934                       ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
15935
15936                     }
15937                   break;
15938               }
15939             break;
15940           case 0x81:
15941               GETBYTE ();
15942               switch (op[2] & 0x00)
15943               {
15944                 case 0x00:
15945                   goto op_semantics_123;
15946                   break;
15947               }
15948             break;
15949           case 0x82:
15950               GETBYTE ();
15951               switch (op[2] & 0x00)
15952               {
15953                 case 0x00:
15954                   goto op_semantics_123;
15955                   break;
15956               }
15957             break;
15958           case 0x83:
15959               GETBYTE ();
15960               switch (op[2] & 0x00)
15961               {
15962                 case 0x00:
15963                   goto op_semantics_123;
15964                   break;
15965               }
15966             break;
15967           case 0x84:
15968               GETBYTE ();
15969               switch (op[2] & 0x00)
15970               {
15971                 case 0x00:
15972                   goto op_semantics_123;
15973                   break;
15974               }
15975             break;
15976           case 0x85:
15977               GETBYTE ();
15978               switch (op[2] & 0x00)
15979               {
15980                 case 0x00:
15981                   goto op_semantics_123;
15982                   break;
15983               }
15984             break;
15985           case 0x86:
15986               GETBYTE ();
15987               switch (op[2] & 0x00)
15988               {
15989                 case 0x00:
15990                   goto op_semantics_123;
15991                   break;
15992               }
15993             break;
15994           case 0x87:
15995               GETBYTE ();
15996               switch (op[2] & 0x00)
15997               {
15998                 case 0x00:
15999                   goto op_semantics_123;
16000                   break;
16001               }
16002             break;
16003           case 0x88:
16004               GETBYTE ();
16005               switch (op[2] & 0x00)
16006               {
16007                 case 0x00:
16008                   goto op_semantics_123;
16009                   break;
16010               }
16011             break;
16012           case 0x89:
16013               GETBYTE ();
16014               switch (op[2] & 0x00)
16015               {
16016                 case 0x00:
16017                   goto op_semantics_123;
16018                   break;
16019               }
16020             break;
16021           case 0x8a:
16022               GETBYTE ();
16023               switch (op[2] & 0x00)
16024               {
16025                 case 0x00:
16026                   goto op_semantics_123;
16027                   break;
16028               }
16029             break;
16030           case 0x8b:
16031               GETBYTE ();
16032               switch (op[2] & 0x00)
16033               {
16034                 case 0x00:
16035                   goto op_semantics_123;
16036                   break;
16037               }
16038             break;
16039           case 0x8c:
16040               GETBYTE ();
16041               switch (op[2] & 0x00)
16042               {
16043                 case 0x00:
16044                   goto op_semantics_123;
16045                   break;
16046               }
16047             break;
16048           case 0x8d:
16049               GETBYTE ();
16050               switch (op[2] & 0x00)
16051               {
16052                 case 0x00:
16053                   goto op_semantics_123;
16054                   break;
16055               }
16056             break;
16057           case 0x8e:
16058               GETBYTE ();
16059               switch (op[2] & 0x00)
16060               {
16061                 case 0x00:
16062                   goto op_semantics_123;
16063                   break;
16064               }
16065             break;
16066           case 0x8f:
16067               GETBYTE ();
16068               switch (op[2] & 0x00)
16069               {
16070                 case 0x00:
16071                   goto op_semantics_123;
16072                   break;
16073               }
16074             break;
16075           case 0xa0:
16076               GETBYTE ();
16077               switch (op[2] & 0x00)
16078               {
16079                 case 0x00:
16080                   op_semantics_124:
16081                     {
16082                       /** 1111 1111 1010 rdst srca srcb fadd    %2, %1, %0 */
16083 #line 1097 "rx-decode.opc"
16084                       int rdst AU = op[1] & 0x0f;
16085 #line 1097 "rx-decode.opc"
16086                       int srca AU = (op[2] >> 4) & 0x0f;
16087 #line 1097 "rx-decode.opc"
16088                       int srcb AU = op[2] & 0x0f;
16089                       if (trace)
16090                         {
16091                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16092                                  "/** 1111 1111 1010 rdst srca srcb     fadd    %2, %1, %0 */",
16093                                  op[0], op[1], op[2]);
16094                           printf ("  rdst = 0x%x,", rdst);
16095                           printf ("  srca = 0x%x,", srca);
16096                           printf ("  srcb = 0x%x\n", srcb);
16097                         }
16098                       SYNTAX("fadd      %2, %1, %0");
16099 #line 1097 "rx-decode.opc"
16100                       ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
16101
16102                     }
16103                   break;
16104               }
16105             break;
16106           case 0xa1:
16107               GETBYTE ();
16108               switch (op[2] & 0x00)
16109               {
16110                 case 0x00:
16111                   goto op_semantics_124;
16112                   break;
16113               }
16114             break;
16115           case 0xa2:
16116               GETBYTE ();
16117               switch (op[2] & 0x00)
16118               {
16119                 case 0x00:
16120                   goto op_semantics_124;
16121                   break;
16122               }
16123             break;
16124           case 0xa3:
16125               GETBYTE ();
16126               switch (op[2] & 0x00)
16127               {
16128                 case 0x00:
16129                   goto op_semantics_124;
16130                   break;
16131               }
16132             break;
16133           case 0xa4:
16134               GETBYTE ();
16135               switch (op[2] & 0x00)
16136               {
16137                 case 0x00:
16138                   goto op_semantics_124;
16139                   break;
16140               }
16141             break;
16142           case 0xa5:
16143               GETBYTE ();
16144               switch (op[2] & 0x00)
16145               {
16146                 case 0x00:
16147                   goto op_semantics_124;
16148                   break;
16149               }
16150             break;
16151           case 0xa6:
16152               GETBYTE ();
16153               switch (op[2] & 0x00)
16154               {
16155                 case 0x00:
16156                   goto op_semantics_124;
16157                   break;
16158               }
16159             break;
16160           case 0xa7:
16161               GETBYTE ();
16162               switch (op[2] & 0x00)
16163               {
16164                 case 0x00:
16165                   goto op_semantics_124;
16166                   break;
16167               }
16168             break;
16169           case 0xa8:
16170               GETBYTE ();
16171               switch (op[2] & 0x00)
16172               {
16173                 case 0x00:
16174                   goto op_semantics_124;
16175                   break;
16176               }
16177             break;
16178           case 0xa9:
16179               GETBYTE ();
16180               switch (op[2] & 0x00)
16181               {
16182                 case 0x00:
16183                   goto op_semantics_124;
16184                   break;
16185               }
16186             break;
16187           case 0xaa:
16188               GETBYTE ();
16189               switch (op[2] & 0x00)
16190               {
16191                 case 0x00:
16192                   goto op_semantics_124;
16193                   break;
16194               }
16195             break;
16196           case 0xab:
16197               GETBYTE ();
16198               switch (op[2] & 0x00)
16199               {
16200                 case 0x00:
16201                   goto op_semantics_124;
16202                   break;
16203               }
16204             break;
16205           case 0xac:
16206               GETBYTE ();
16207               switch (op[2] & 0x00)
16208               {
16209                 case 0x00:
16210                   goto op_semantics_124;
16211                   break;
16212               }
16213             break;
16214           case 0xad:
16215               GETBYTE ();
16216               switch (op[2] & 0x00)
16217               {
16218                 case 0x00:
16219                   goto op_semantics_124;
16220                   break;
16221               }
16222             break;
16223           case 0xae:
16224               GETBYTE ();
16225               switch (op[2] & 0x00)
16226               {
16227                 case 0x00:
16228                   goto op_semantics_124;
16229                   break;
16230               }
16231             break;
16232           case 0xaf:
16233               GETBYTE ();
16234               switch (op[2] & 0x00)
16235               {
16236                 case 0x00:
16237                   goto op_semantics_124;
16238                   break;
16239               }
16240             break;
16241           case 0xb0:
16242               GETBYTE ();
16243               switch (op[2] & 0x00)
16244               {
16245                 case 0x00:
16246                   op_semantics_125:
16247                     {
16248                       /** 1111 1111 1011 rdst srca srcb fmul    %2, %1, %0 */
16249 #line 1103 "rx-decode.opc"
16250                       int rdst AU = op[1] & 0x0f;
16251 #line 1103 "rx-decode.opc"
16252                       int srca AU = (op[2] >> 4) & 0x0f;
16253 #line 1103 "rx-decode.opc"
16254                       int srcb AU = op[2] & 0x0f;
16255                       if (trace)
16256                         {
16257                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16258                                  "/** 1111 1111 1011 rdst srca srcb     fmul    %2, %1, %0 */",
16259                                  op[0], op[1], op[2]);
16260                           printf ("  rdst = 0x%x,", rdst);
16261                           printf ("  srca = 0x%x,", srca);
16262                           printf ("  srcb = 0x%x\n", srcb);
16263                         }
16264                       SYNTAX("fmul      %2, %1, %0");
16265 #line 1103 "rx-decode.opc"
16266                       ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
16267
16268                     }
16269                   break;
16270               }
16271             break;
16272           case 0xb1:
16273               GETBYTE ();
16274               switch (op[2] & 0x00)
16275               {
16276                 case 0x00:
16277                   goto op_semantics_125;
16278                   break;
16279               }
16280             break;
16281           case 0xb2:
16282               GETBYTE ();
16283               switch (op[2] & 0x00)
16284               {
16285                 case 0x00:
16286                   goto op_semantics_125;
16287                   break;
16288               }
16289             break;
16290           case 0xb3:
16291               GETBYTE ();
16292               switch (op[2] & 0x00)
16293               {
16294                 case 0x00:
16295                   goto op_semantics_125;
16296                   break;
16297               }
16298             break;
16299           case 0xb4:
16300               GETBYTE ();
16301               switch (op[2] & 0x00)
16302               {
16303                 case 0x00:
16304                   goto op_semantics_125;
16305                   break;
16306               }
16307             break;
16308           case 0xb5:
16309               GETBYTE ();
16310               switch (op[2] & 0x00)
16311               {
16312                 case 0x00:
16313                   goto op_semantics_125;
16314                   break;
16315               }
16316             break;
16317           case 0xb6:
16318               GETBYTE ();
16319               switch (op[2] & 0x00)
16320               {
16321                 case 0x00:
16322                   goto op_semantics_125;
16323                   break;
16324               }
16325             break;
16326           case 0xb7:
16327               GETBYTE ();
16328               switch (op[2] & 0x00)
16329               {
16330                 case 0x00:
16331                   goto op_semantics_125;
16332                   break;
16333               }
16334             break;
16335           case 0xb8:
16336               GETBYTE ();
16337               switch (op[2] & 0x00)
16338               {
16339                 case 0x00:
16340                   goto op_semantics_125;
16341                   break;
16342               }
16343             break;
16344           case 0xb9:
16345               GETBYTE ();
16346               switch (op[2] & 0x00)
16347               {
16348                 case 0x00:
16349                   goto op_semantics_125;
16350                   break;
16351               }
16352             break;
16353           case 0xba:
16354               GETBYTE ();
16355               switch (op[2] & 0x00)
16356               {
16357                 case 0x00:
16358                   goto op_semantics_125;
16359                   break;
16360               }
16361             break;
16362           case 0xbb:
16363               GETBYTE ();
16364               switch (op[2] & 0x00)
16365               {
16366                 case 0x00:
16367                   goto op_semantics_125;
16368                   break;
16369               }
16370             break;
16371           case 0xbc:
16372               GETBYTE ();
16373               switch (op[2] & 0x00)
16374               {
16375                 case 0x00:
16376                   goto op_semantics_125;
16377                   break;
16378               }
16379             break;
16380           case 0xbd:
16381               GETBYTE ();
16382               switch (op[2] & 0x00)
16383               {
16384                 case 0x00:
16385                   goto op_semantics_125;
16386                   break;
16387               }
16388             break;
16389           case 0xbe:
16390               GETBYTE ();
16391               switch (op[2] & 0x00)
16392               {
16393                 case 0x00:
16394                   goto op_semantics_125;
16395                   break;
16396               }
16397             break;
16398           case 0xbf:
16399               GETBYTE ();
16400               switch (op[2] & 0x00)
16401               {
16402                 case 0x00:
16403                   goto op_semantics_125;
16404                   break;
16405               }
16406             break;
16407           default: UNSUPPORTED(); break;
16408         }
16409       break;
16410     default: UNSUPPORTED(); break;
16411   }
16412 #line 1118 "rx-decode.opc"
16413
16414   return rx->n_bytes;
16415 }