opcodes/rl78-decode.c

   1 #line 1 "rl78-decode.opc"
   2 /* -*- c -*- */
   3 /* Copyright (C) 2012-2017 Free Software Foundation, Inc.
   4    Contributed by Red Hat.
   5    Written by DJ Delorie.
   6
   7    This file is part of the GNU opcodes library.
   8
   9    This library is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3, or (at your option)
  12    any later version.
  13
  14    It is distributed in the hope that it will be useful, but WITHOUT
  15    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  17    License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 #include "sysdep.h"
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include "ansidecl.h"
  29 #include "opcode/rl78.h"
  30
  31 static int trace = 0;
  32
  33 typedef struct
  34 {
  35   RL78_Opcode_Decoded * rl78;
  36   int (* getbyte)(void *);
  37   void * ptr;
  38   unsigned char * op;
  39 } LocalData;
  40
  41 #define ID(x) rl78->id = RLO_##x, rl78->lineno = __LINE__
  42 #define OP(n,t,r,a) (rl78->op[n].type = t, \
  43                      rl78->op[n].reg = r,            \
  44                      rl78->op[n].addend = a )
  45 #define OPX(n,t,r1,r2,a) \
  46         (rl78->op[n].type = t, \
  47         rl78->op[n].reg = r1, \
  48         rl78->op[n].reg2 = r2, \
  49         rl78->op[n].addend = a )
  50
  51 #define W() rl78->size = RL78_Word
  52
  53 #define AU ATTRIBUTE_UNUSED
  54
  55 #define OP_BUF_LEN 20
  56 #define GETBYTE() (ld->rl78->n_bytes < (OP_BUF_LEN - 1) ? ld->op [ld->rl78->n_bytes++] = ld->getbyte (ld->ptr): 0)
  57 #define B ((unsigned long) GETBYTE())
  58
  59 #define SYNTAX(x) rl78->syntax = x
  60
  61 #define UNSUPPORTED() \
  62   rl78->syntax = "*unknown*"
  63
  64 #define RB(x) ((x)+RL78_Reg_X)
  65 #define RW(x) ((x)+RL78_Reg_AX)
  66
  67 #define Fz      rl78->flags = RL78_PSW_Z
  68 #define Fza     rl78->flags = RL78_PSW_Z | RL78_PSW_AC
  69 #define Fzc     rl78->flags = RL78_PSW_Z | RL78_PSW_CY
  70 #define Fzac    rl78->flags = RL78_PSW_Z | RL78_PSW_AC | RL78_PSW_CY
  71 #define Fa      rl78->flags = RL78_PSW_AC
  72 #define Fc      rl78->flags = RL78_PSW_CY
  73 #define Fac     rl78->flags = RL78_PSW_AC | RL78_PSW_CY
  74
  75 #define IMMU(bytes)   immediate (bytes, 0, ld)
  76 #define IMMS(bytes)   immediate (bytes, 1, ld)
  77
  78 static int
  79 immediate (int bytes, int sign_extend, LocalData * ld)
  80 {
  81   unsigned long i = 0;
  82
  83   switch (bytes)
  84     {
  85     case 1:
  86       i |= B;
  87       if (sign_extend && (i & 0x80))
  88         i -= 0x100;
  89       break;
  90     case 2:
  91       i |= B;
  92       i |= B << 8;
  93       if (sign_extend && (i & 0x8000))
  94         i -= 0x10000;
  95       break;
  96     case 3:
  97       i |= B;
  98       i |= B << 8;
  99       i |= B << 16;
 100       if (sign_extend && (i & 0x800000))
 101         i -= 0x1000000;
 102       break;
 103     default:
 104       fprintf (stderr, "Programmer error: immediate() called with invalid byte count %d\n", bytes);
 105       abort();
 106     }
 107   return i;
 108 }
 109
 110 #define DC(c)           OP (0, RL78_Operand_Immediate, 0, c)
 111 #define DR(r)           OP (0, RL78_Operand_Register, RL78_Reg_##r, 0)
 112 #define DRB(r)          OP (0, RL78_Operand_Register, RB(r), 0)
 113 #define DRW(r)          OP (0, RL78_Operand_Register, RW(r), 0)
 114 #define DM(r,a)         OP (0, RL78_Operand_Indirect, RL78_Reg_##r, a)
 115 #define DM2(r1,r2,a)    OPX (0, RL78_Operand_Indirect, RL78_Reg_##r1, RL78_Reg_##r2, a)
 116 #define DE()            rl78->op[0].use_es = 1
 117 #define DB(b)           set_bit (rl78->op, b)
 118 #define DCY()           DR(PSW); DB(0)
 119 #define DPUSH()         OP (0, RL78_Operand_PreDec, RL78_Reg_SP, 0);
 120
 121 #define SC(c)           OP (1, RL78_Operand_Immediate, 0, c)
 122 #define SR(r)           OP (1, RL78_Operand_Register, RL78_Reg_##r, 0)
 123 #define SRB(r)          OP (1, RL78_Operand_Register, RB(r), 0)
 124 #define SRW(r)          OP (1, RL78_Operand_Register, RW(r), 0)
 125 #define SM(r,a)         OP (1, RL78_Operand_Indirect, RL78_Reg_##r, a)
 126 #define SM2(r1,r2,a)    OPX (1, RL78_Operand_Indirect, RL78_Reg_##r1, RL78_Reg_##r2, a)
 127 #define SE()            rl78->op[1].use_es = 1
 128 #define SB(b)           set_bit (rl78->op+1, b)
 129 #define SCY()           SR(PSW); SB(0)
 130 #define COND(c)         rl78->op[1].condition = RL78_Condition_##c
 131 #define SPOP()          OP (1, RL78_Operand_PostInc, RL78_Reg_SP, 0);
 132
 133 static void
 134 set_bit (RL78_Opcode_Operand *op, int bit)
 135 {
 136   op->bit_number = bit;
 137   switch (op->type) {
 138   case RL78_Operand_Register:
 139     op->type = RL78_Operand_Bit;
 140     break;
 141   case RL78_Operand_Indirect:
 142     op->type = RL78_Operand_BitIndirect;
 143     break;
 144   default:
 145     break;
 146   }
 147 }
 148
 149 static int
 150 saddr (int x)
 151 {
 152   if (x < 0x20)
 153     return 0xfff00 + x;
 154   return 0xffe00 + x;
 155 }
 156
 157 static int
 158 sfr (int x)
 159 {
 160   return 0xfff00 + x;
 161 }
 162
 163 #define SADDR saddr (IMMU (1))
 164 #define SFR sfr (IMMU (1))
 165
 166 int
 167 rl78_decode_opcode (unsigned long pc AU,
 168                   RL78_Opcode_Decoded * rl78,
 169                   int (* getbyte)(void *),
 170                   void * ptr,
 171                   RL78_Dis_Isa isa)
 172 {
 173   LocalData lds, * ld = &lds;
 174   unsigned char op_buf[OP_BUF_LEN] = {0};
 175   unsigned char *op = op_buf;
 176   int op0, op1;
 177
 178   lds.rl78 = rl78;
 179   lds.getbyte = getbyte;
 180   lds.ptr = ptr;
 181   lds.op = op;
 182
 183   memset (rl78, 0, sizeof (*rl78));
 184
 185  start_again:
 186
 187 /* Byte registers, not including A.  */
 188 /* Word registers, not including AX.  */
 189
 190 /*----------------------------------------------------------------------*/
 191 /* ES: prefix                                                           */
 192
 193   GETBYTE ();
 194   switch (op[0] & 0xff)
 195   {
 196     case 0x00:
 197         {
 198           /** 0000 0000                 nop                                     */
 199           if (trace)
 200             {
 201               printf ("\033[33m%s\033[0m  %02x\n",
 202                      "/** 0000 0000                     nop                                     */",
 203                      op[0]);
 204             }
 205           SYNTAX("nop");
 206 #line 913 "rl78-decode.opc"
 207           ID(nop);
 208
 209         /*----------------------------------------------------------------------*/
 210
 211         }
 212       break;
 213     case 0x01:
 214     case 0x03:
 215     case 0x05:
 216     case 0x07:
 217         {
 218           /** 0000 0rw1                 addw    %0, %1                          */
 219 #line 276 "rl78-decode.opc"
 220           int rw AU = (op[0] >> 1) & 0x03;
 221           if (trace)
 222             {
 223               printf ("\033[33m%s\033[0m  %02x\n",
 224                      "/** 0000 0rw1                     addw    %0, %1                          */",
 225                      op[0]);
 226               printf ("  rw = 0x%x\n", rw);
 227             }
 228           SYNTAX("addw  %0, %1");
 229 #line 276 "rl78-decode.opc"
 230           ID(add); W(); DR(AX); SRW(rw); Fzac;
 231
 232         }
 233       break;
 234     case 0x02:
 235         {
 236           /** 0000 0010                 addw    %0, %e!1                        */
 237           if (trace)
 238             {
 239               printf ("\033[33m%s\033[0m  %02x\n",
 240                      "/** 0000 0010                     addw    %0, %e!1                        */",
 241                      op[0]);
 242             }
 243           SYNTAX("addw  %0, %e!1");
 244 #line 267 "rl78-decode.opc"
 245           ID(add); W(); DR(AX); SM(None, IMMU(2)); Fzac;
 246
 247         }
 248       break;
 249     case 0x04:
 250         {
 251           /** 0000 0100                 addw    %0, #%1                         */
 252           if (trace)
 253             {
 254               printf ("\033[33m%s\033[0m  %02x\n",
 255                      "/** 0000 0100                     addw    %0, #%1                         */",
 256                      op[0]);
 257             }
 258           SYNTAX("addw  %0, #%1");
 259 #line 273 "rl78-decode.opc"
 260           ID(add); W(); DR(AX); SC(IMMU(2)); Fzac;
 261
 262         }
 263       break;
 264     case 0x06:
 265         {
 266           /** 0000 0110                 addw    %0, %1                          */
 267           if (trace)
 268             {
 269               printf ("\033[33m%s\033[0m  %02x\n",
 270                      "/** 0000 0110                     addw    %0, %1                          */",
 271                      op[0]);
 272             }
 273           SYNTAX("addw  %0, %1");
 274 #line 279 "rl78-decode.opc"
 275           ID(add); W(); DR(AX); SM(None, SADDR); Fzac;
 276
 277         }
 278       break;
 279     case 0x08:
 280         {
 281           /** 0000 1000                 xch     a, x                            */
 282           if (trace)
 283             {
 284               printf ("\033[33m%s\033[0m  %02x\n",
 285                      "/** 0000 1000                     xch     a, x                            */",
 286                      op[0]);
 287             }
 288           SYNTAX("xch   a, x");
 289 #line 1236 "rl78-decode.opc"
 290           ID(xch); DR(A); SR(X);
 291
 292         /*----------------------------------------------------------------------*/
 293
 294         }
 295       break;
 296     case 0x09:
 297         {
 298           /** 0000 1001                 mov     %0, %e1                         */
 299           if (trace)
 300             {
 301               printf ("\033[33m%s\033[0m  %02x\n",
 302                      "/** 0000 1001                     mov     %0, %e1                         */",
 303                      op[0]);
 304             }
 305           SYNTAX("mov   %0, %e1");
 306 #line 680 "rl78-decode.opc"
 307           ID(mov); DR(A); SM(B, IMMU(2));
 308
 309         }
 310       break;
 311     case 0x0a:
 312         {
 313           /** 0000 1010                 add     %0, #%1                         */
 314           if (trace)
 315             {
 316               printf ("\033[33m%s\033[0m  %02x\n",
 317                      "/** 0000 1010                     add     %0, #%1                         */",
 318                      op[0]);
 319             }
 320           SYNTAX("add   %0, #%1");
 321 #line 230 "rl78-decode.opc"
 322           ID(add); DM(None, SADDR); SC(IMMU(1)); Fzac;
 323
 324         /*----------------------------------------------------------------------*/
 325
 326         }
 327       break;
 328     case 0x0b:
 329         {
 330           /** 0000 1011                 add     %0, %1                          */
 331           if (trace)
 332             {
 333               printf ("\033[33m%s\033[0m  %02x\n",
 334                      "/** 0000 1011                     add     %0, %1                          */",
 335                      op[0]);
 336             }
 337           SYNTAX("add   %0, %1");
 338 #line 224 "rl78-decode.opc"
 339           ID(add); DR(A); SM(None, SADDR); Fzac;
 340
 341         }
 342       break;
 343     case 0x0c:
 344         {
 345           /** 0000 1100                 add     %0, #%1                         */
 346           if (trace)
 347             {
 348               printf ("\033[33m%s\033[0m  %02x\n",
 349                      "/** 0000 1100                     add     %0, #%1                         */",
 350                      op[0]);
 351             }
 352           SYNTAX("add   %0, #%1");
 353 #line 218 "rl78-decode.opc"
 354           ID(add); DR(A); SC(IMMU(1)); Fzac;
 355
 356         }
 357       break;
 358     case 0x0d:
 359         {
 360           /** 0000 1101                 add     %0, %e1                         */
 361           if (trace)
 362             {
 363               printf ("\033[33m%s\033[0m  %02x\n",
 364                      "/** 0000 1101                     add     %0, %e1                         */",
 365                      op[0]);
 366             }
 367           SYNTAX("add   %0, %e1");
 368 #line 206 "rl78-decode.opc"
 369           ID(add); DR(A); SM(HL, 0); Fzac;
 370
 371         }
 372       break;
 373     case 0x0e:
 374         {
 375           /** 0000 1110                 add     %0, %ea1                        */
 376           if (trace)
 377             {
 378               printf ("\033[33m%s\033[0m  %02x\n",
 379                      "/** 0000 1110                     add     %0, %ea1                        */",
 380                      op[0]);
 381             }
 382           SYNTAX("add   %0, %ea1");
 383 #line 212 "rl78-decode.opc"
 384           ID(add); DR(A); SM(HL, IMMU(1)); Fzac;
 385
 386         }
 387       break;
 388     case 0x0f:
 389         {
 390           /** 0000 1111                 add     %0, %e!1                        */
 391           if (trace)
 392             {
 393               printf ("\033[33m%s\033[0m  %02x\n",
 394                      "/** 0000 1111                     add     %0, %e!1                        */",
 395                      op[0]);
 396             }
 397           SYNTAX("add   %0, %e!1");
 398 #line 203 "rl78-decode.opc"
 399           ID(add); DR(A); SM(None, IMMU(2)); Fzac;
 400
 401         }
 402       break;
 403     case 0x10:
 404         {
 405           /** 0001 0000                 addw    %0, #%1                         */
 406           if (trace)
 407             {
 408               printf ("\033[33m%s\033[0m  %02x\n",
 409                      "/** 0001 0000                     addw    %0, #%1                         */",
 410                      op[0]);
 411             }
 412           SYNTAX("addw  %0, #%1");
 413 #line 282 "rl78-decode.opc"
 414           ID(add); W(); DR(SP); SC(IMMU(1)); Fzac;
 415
 416         /*----------------------------------------------------------------------*/
 417
 418         }
 419       break;
 420     case 0x11:
 421         {
 422           /** 0001 0001                 es:                                     */
 423           if (trace)
 424             {
 425               printf ("\033[33m%s\033[0m  %02x\n",
 426                      "/** 0001 0001                     es:                                     */",
 427                      op[0]);
 428             }
 429           SYNTAX("es:");
 430 #line 195 "rl78-decode.opc"
 431           DE(); SE();
 432           op ++;
 433           pc ++;
 434           goto start_again;
 435
 436         /*----------------------------------------------------------------------*/
 437
 438         }
 439       break;
 440     case 0x12:
 441     case 0x14:
 442     case 0x16:
 443         {
 444           /** 0001 0ra0                 movw    %0, %1                          */
 445 #line 861 "rl78-decode.opc"
 446           int ra AU = (op[0] >> 1) & 0x03;
 447           if (trace)
 448             {
 449               printf ("\033[33m%s\033[0m  %02x\n",
 450                      "/** 0001 0ra0                     movw    %0, %1                          */",
 451                      op[0]);
 452               printf ("  ra = 0x%x\n", ra);
 453             }
 454           SYNTAX("movw  %0, %1");
 455 #line 861 "rl78-decode.opc"
 456           ID(mov); W(); DRW(ra); SR(AX);
 457
 458         }
 459       break;
 460     case 0x13:
 461     case 0x15:
 462     case 0x17:
 463         {
 464           /** 0001 0ra1                 movw    %0, %1                          */
 465 #line 858 "rl78-decode.opc"
 466           int ra AU = (op[0] >> 1) & 0x03;
 467           if (trace)
 468             {
 469               printf ("\033[33m%s\033[0m  %02x\n",
 470                      "/** 0001 0ra1                     movw    %0, %1                          */",
 471                      op[0]);
 472               printf ("  ra = 0x%x\n", ra);
 473             }
 474           SYNTAX("movw  %0, %1");
 475 #line 858 "rl78-decode.opc"
 476           ID(mov); W(); DR(AX); SRW(ra);
 477
 478         }
 479       break;
 480     case 0x18:
 481         {
 482           /** 0001 1000                 mov     %e0, %1                         */
 483           if (trace)
 484             {
 485               printf ("\033[33m%s\033[0m  %02x\n",
 486                      "/** 0001 1000                     mov     %e0, %1                         */",
 487                      op[0]);
 488             }
 489           SYNTAX("mov   %e0, %1");
 490 #line 731 "rl78-decode.opc"
 491           ID(mov); DM(B, IMMU(2)); SR(A);
 492
 493         }
 494       break;
 495     case 0x19:
 496         {
 497           /** 0001 1001                 mov     %e0, #%1                        */
 498           if (trace)
 499             {
 500               printf ("\033[33m%s\033[0m  %02x\n",
 501                      "/** 0001 1001                     mov     %e0, #%1                        */",
 502                      op[0]);
 503             }
 504           SYNTAX("mov   %e0, #%1");
 505 #line 728 "rl78-decode.opc"
 506           ID(mov); DM(B, IMMU(2)); SC(IMMU(1));
 507
 508         }
 509       break;
 510     case 0x1a:
 511         {
 512           /** 0001 1010                 addc    %0, #%1                         */
 513           if (trace)
 514             {
 515               printf ("\033[33m%s\033[0m  %02x\n",
 516                      "/** 0001 1010                     addc    %0, #%1                         */",
 517                      op[0]);
 518             }
 519           SYNTAX("addc  %0, #%1");
 520 #line 262 "rl78-decode.opc"
 521           ID(addc); DM(None, SADDR); SC(IMMU(1)); Fzac;
 522
 523         /*----------------------------------------------------------------------*/
 524
 525         }
 526       break;
 527     case 0x1b:
 528         {
 529           /** 0001 1011                 addc    %0, %1                          */
 530           if (trace)
 531             {
 532               printf ("\033[33m%s\033[0m  %02x\n",
 533                      "/** 0001 1011                     addc    %0, %1                          */",
 534                      op[0]);
 535             }
 536           SYNTAX("addc  %0, %1");
 537 #line 259 "rl78-decode.opc"
 538           ID(addc); DR(A); SM(None, SADDR); Fzac;
 539
 540         }
 541       break;
 542     case 0x1c:
 543         {
 544           /** 0001 1100                 addc    %0, #%1                         */
 545           if (trace)
 546             {
 547               printf ("\033[33m%s\033[0m  %02x\n",
 548                      "/** 0001 1100                     addc    %0, #%1                         */",
 549                      op[0]);
 550             }
 551           SYNTAX("addc  %0, #%1");
 552 #line 250 "rl78-decode.opc"
 553           ID(addc); DR(A); SC(IMMU(1)); Fzac;
 554
 555         }
 556       break;
 557     case 0x1d:
 558         {
 559           /** 0001 1101                 addc    %0, %e1                         */
 560           if (trace)
 561             {
 562               printf ("\033[33m%s\033[0m  %02x\n",
 563                      "/** 0001 1101                     addc    %0, %e1                         */",
 564                      op[0]);
 565             }
 566           SYNTAX("addc  %0, %e1");
 567 #line 238 "rl78-decode.opc"
 568           ID(addc); DR(A); SM(HL, 0); Fzac;
 569
 570         }
 571       break;
 572     case 0x1e:
 573         {
 574           /** 0001 1110                 addc    %0, %ea1                        */
 575           if (trace)
 576             {
 577               printf ("\033[33m%s\033[0m  %02x\n",
 578                      "/** 0001 1110                     addc    %0, %ea1                        */",
 579                      op[0]);
 580             }
 581           SYNTAX("addc  %0, %ea1");
 582 #line 247 "rl78-decode.opc"
 583           ID(addc); DR(A); SM(HL, IMMU(1)); Fzac;
 584
 585         }
 586       break;
 587     case 0x1f:
 588         {
 589           /** 0001 1111                 addc    %0, %e!1                        */
 590           if (trace)
 591             {
 592               printf ("\033[33m%s\033[0m  %02x\n",
 593                      "/** 0001 1111                     addc    %0, %e!1                        */",
 594                      op[0]);
 595             }
 596           SYNTAX("addc  %0, %e!1");
 597 #line 235 "rl78-decode.opc"
 598           ID(addc); DR(A); SM(None, IMMU(2)); Fzac;
 599
 600         }
 601       break;
 602     case 0x20:
 603         {
 604           /** 0010 0000                 subw    %0, #%1                         */
 605           if (trace)
 606             {
 607               printf ("\033[33m%s\033[0m  %02x\n",
 608                      "/** 0010 0000                     subw    %0, #%1                         */",
 609                      op[0]);
 610             }
 611           SYNTAX("subw  %0, #%1");
 612 #line 1200 "rl78-decode.opc"
 613           ID(sub); W(); DR(SP); SC(IMMU(1)); Fzac;
 614
 615         /*----------------------------------------------------------------------*/
 616
 617         }
 618       break;
 619     case 0x21:
 620     case 0x23:
 621     case 0x25:
 622     case 0x27:
 623         {
 624           /** 0010 0rw1                 subw    %0, %1                          */
 625 #line 1194 "rl78-decode.opc"
 626           int rw AU = (op[0] >> 1) & 0x03;
 627           if (trace)
 628             {
 629               printf ("\033[33m%s\033[0m  %02x\n",
 630                      "/** 0010 0rw1                     subw    %0, %1                          */",
 631                      op[0]);
 632               printf ("  rw = 0x%x\n", rw);
 633             }
 634           SYNTAX("subw  %0, %1");
 635 #line 1194 "rl78-decode.opc"
 636           ID(sub); W(); DR(AX); SRW(rw); Fzac;
 637
 638         }
 639       break;
 640     case 0x22:
 641         {
 642           /** 0010 0010                 subw    %0, %e!1                        */
 643           if (trace)
 644             {
 645               printf ("\033[33m%s\033[0m  %02x\n",
 646                      "/** 0010 0010                     subw    %0, %e!1                        */",
 647                      op[0]);
 648             }
 649           SYNTAX("subw  %0, %e!1");
 650 #line 1185 "rl78-decode.opc"
 651           ID(sub); W(); DR(AX); SM(None, IMMU(2)); Fzac;
 652
 653         }
 654       break;
 655     case 0x24:
 656         {
 657           /** 0010 0100                 subw    %0, #%1                         */
 658           if (trace)
 659             {
 660               printf ("\033[33m%s\033[0m  %02x\n",
 661                      "/** 0010 0100                     subw    %0, #%1                         */",
 662                      op[0]);
 663             }
 664           SYNTAX("subw  %0, #%1");
 665 #line 1191 "rl78-decode.opc"
 666           ID(sub); W(); DR(AX); SC(IMMU(2)); Fzac;
 667
 668         }
 669       break;
 670     case 0x26:
 671         {
 672           /** 0010 0110                 subw    %0, %1                          */
 673           if (trace)
 674             {
 675               printf ("\033[33m%s\033[0m  %02x\n",
 676                      "/** 0010 0110                     subw    %0, %1                          */",
 677                      op[0]);
 678             }
 679           SYNTAX("subw  %0, %1");
 680 #line 1197 "rl78-decode.opc"
 681           ID(sub); W(); DR(AX); SM(None, SADDR); Fzac;
 682
 683         }
 684       break;
 685     case 0x28:
 686         {
 687           /** 0010 1000                 mov     %e0, %1                         */
 688           if (trace)
 689             {
 690               printf ("\033[33m%s\033[0m  %02x\n",
 691                      "/** 0010 1000                     mov     %e0, %1                         */",
 692                      op[0]);
 693             }
 694           SYNTAX("mov   %e0, %1");
 695 #line 743 "rl78-decode.opc"
 696           ID(mov); DM(C, IMMU(2)); SR(A);
 697
 698         }
 699       break;
 700     case 0x29:
 701         {
 702           /** 0010 1001                 mov     %0, %e1                         */
 703           if (trace)
 704             {
 705               printf ("\033[33m%s\033[0m  %02x\n",
 706                      "/** 0010 1001                     mov     %0, %e1                         */",
 707                      op[0]);
 708             }
 709           SYNTAX("mov   %0, %e1");
 710 #line 686 "rl78-decode.opc"
 711           ID(mov); DR(A); SM(C, IMMU(2));
 712
 713         }
 714       break;
 715     case 0x2a:
 716         {
 717           /** 0010 1010                 sub     %0, #%1                         */
 718           if (trace)
 719             {
 720               printf ("\033[33m%s\033[0m  %02x\n",
 721                      "/** 0010 1010                     sub     %0, #%1                         */",
 722                      op[0]);
 723             }
 724           SYNTAX("sub   %0, #%1");
 725 #line 1148 "rl78-decode.opc"
 726           ID(sub); DM(None, SADDR); SC(IMMU(1)); Fzac;
 727
 728         /*----------------------------------------------------------------------*/
 729
 730         }
 731       break;
 732     case 0x2b:
 733         {
 734           /** 0010 1011                 sub     %0, %1                          */
 735           if (trace)
 736             {
 737               printf ("\033[33m%s\033[0m  %02x\n",
 738                      "/** 0010 1011                     sub     %0, %1                          */",
 739                      op[0]);
 740             }
 741           SYNTAX("sub   %0, %1");
 742 #line 1142 "rl78-decode.opc"
 743           ID(sub); DR(A); SM(None, SADDR); Fzac;
 744
 745         }
 746       break;
 747     case 0x2c:
 748         {
 749           /** 0010 1100                 sub     %0, #%1                         */
 750           if (trace)
 751             {
 752               printf ("\033[33m%s\033[0m  %02x\n",
 753                      "/** 0010 1100                     sub     %0, #%1                         */",
 754                      op[0]);
 755             }
 756           SYNTAX("sub   %0, #%1");
 757 #line 1136 "rl78-decode.opc"
 758           ID(sub); DR(A); SC(IMMU(1)); Fzac;
 759
 760         }
 761       break;
 762     case 0x2d:
 763         {
 764           /** 0010 1101                 sub     %0, %e1                         */
 765           if (trace)
 766             {
 767               printf ("\033[33m%s\033[0m  %02x\n",
 768                      "/** 0010 1101                     sub     %0, %e1                         */",
 769                      op[0]);
 770             }
 771           SYNTAX("sub   %0, %e1");
 772 #line 1124 "rl78-decode.opc"
 773           ID(sub); DR(A); SM(HL, 0); Fzac;
 774
 775         }
 776       break;
 777     case 0x2e:
 778         {
 779           /** 0010 1110                 sub     %0, %ea1                        */
 780           if (trace)
 781             {
 782               printf ("\033[33m%s\033[0m  %02x\n",
 783                      "/** 0010 1110                     sub     %0, %ea1                        */",
 784                      op[0]);
 785             }
 786           SYNTAX("sub   %0, %ea1");
 787 #line 1130 "rl78-decode.opc"
 788           ID(sub); DR(A); SM(HL, IMMU(1)); Fzac;
 789
 790         }
 791       break;
 792     case 0x2f:
 793         {
 794           /** 0010 1111                 sub     %0, %e!1                        */
 795           if (trace)
 796             {
 797               printf ("\033[33m%s\033[0m  %02x\n",
 798                      "/** 0010 1111                     sub     %0, %e!1                        */",
 799                      op[0]);
 800             }
 801           SYNTAX("sub   %0, %e!1");
 802 #line 1121 "rl78-decode.opc"
 803           ID(sub); DR(A); SM(None, IMMU(2)); Fzac;
 804
 805         }
 806       break;
 807     case 0x30:
 808     case 0x32:
 809     case 0x34:
 810     case 0x36:
 811         {
 812           /** 0011 0rg0                 movw    %0, #%1                         */
 813 #line 855 "rl78-decode.opc"
 814           int rg AU = (op[0] >> 1) & 0x03;
 815           if (trace)
 816             {
 817               printf ("\033[33m%s\033[0m  %02x\n",
 818                      "/** 0011 0rg0                     movw    %0, #%1                         */",
 819                      op[0]);
 820               printf ("  rg = 0x%x\n", rg);
 821             }
 822           SYNTAX("movw  %0, #%1");
 823 #line 855 "rl78-decode.opc"
 824           ID(mov); W(); DRW(rg); SC(IMMU(2));
 825
 826         }
 827       break;
 828     case 0x31:
 829         GETBYTE ();
 830         switch (op[1] & 0x8f)
 831         {
 832           case 0x00:
 833               {
 834                 /** 0011 0001 0bit 0000         btclr   %s1, $%a0                       */
 835 #line 418 "rl78-decode.opc"
 836                 int bit AU = (op[1] >> 4) & 0x07;
 837                 if (trace)
 838                   {
 839                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 840                            "/** 0011 0001 0bit 0000             btclr   %s1, $%a0                       */",
 841                            op[0], op[1]);
 842                     printf ("  bit = 0x%x\n", bit);
 843                   }
 844                 SYNTAX("btclr   %s1, $%a0");
 845 #line 418 "rl78-decode.opc"
 846                 ID(branch_cond_clear); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
 847
 848               /*----------------------------------------------------------------------*/
 849
 850               }
 851             break;
 852           case 0x01:
 853               {
 854                 /** 0011 0001 0bit 0001         btclr   %1, $%a0                        */
 855 #line 412 "rl78-decode.opc"
 856                 int bit AU = (op[1] >> 4) & 0x07;
 857                 if (trace)
 858                   {
 859                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 860                            "/** 0011 0001 0bit 0001             btclr   %1, $%a0                        */",
 861                            op[0], op[1]);
 862                     printf ("  bit = 0x%x\n", bit);
 863                   }
 864                 SYNTAX("btclr   %1, $%a0");
 865 #line 412 "rl78-decode.opc"
 866                 ID(branch_cond_clear); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(T);
 867
 868               }
 869             break;
 870           case 0x02:
 871               {
 872                 /** 0011 0001 0bit 0010         bt      %s1, $%a0                       */
 873 #line 404 "rl78-decode.opc"
 874                 int bit AU = (op[1] >> 4) & 0x07;
 875                 if (trace)
 876                   {
 877                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 878                            "/** 0011 0001 0bit 0010             bt      %s1, $%a0                       */",
 879                            op[0], op[1]);
 880                     printf ("  bit = 0x%x\n", bit);
 881                   }
 882                 SYNTAX("bt      %s1, $%a0");
 883 #line 404 "rl78-decode.opc"
 884                 ID(branch_cond); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
 885
 886               /*----------------------------------------------------------------------*/
 887
 888               }
 889             break;
 890           case 0x03:
 891               {
 892                 /** 0011 0001 0bit 0011         bt      %1, $%a0                        */
 893 #line 398 "rl78-decode.opc"
 894                 int bit AU = (op[1] >> 4) & 0x07;
 895                 if (trace)
 896                   {
 897                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 898                            "/** 0011 0001 0bit 0011             bt      %1, $%a0                        */",
 899                            op[0], op[1]);
 900                     printf ("  bit = 0x%x\n", bit);
 901                   }
 902                 SYNTAX("bt      %1, $%a0");
 903 #line 398 "rl78-decode.opc"
 904                 ID(branch_cond); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(T);
 905
 906               }
 907             break;
 908           case 0x04:
 909               {
 910                 /** 0011 0001 0bit 0100         bf      %s1, $%a0                       */
 911 #line 365 "rl78-decode.opc"
 912                 int bit AU = (op[1] >> 4) & 0x07;
 913                 if (trace)
 914                   {
 915                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 916                            "/** 0011 0001 0bit 0100             bf      %s1, $%a0                       */",
 917                            op[0], op[1]);
 918                     printf ("  bit = 0x%x\n", bit);
 919                   }
 920                 SYNTAX("bf      %s1, $%a0");
 921 #line 365 "rl78-decode.opc"
 922                 ID(branch_cond); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(F);
 923
 924               /*----------------------------------------------------------------------*/
 925
 926               }
 927             break;
 928           case 0x05:
 929               {
 930                 /** 0011 0001 0bit 0101         bf      %1, $%a0                        */
 931 #line 359 "rl78-decode.opc"
 932                 int bit AU = (op[1] >> 4) & 0x07;
 933                 if (trace)
 934                   {
 935                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 936                            "/** 0011 0001 0bit 0101             bf      %1, $%a0                        */",
 937                            op[0], op[1]);
 938                     printf ("  bit = 0x%x\n", bit);
 939                   }
 940                 SYNTAX("bf      %1, $%a0");
 941 #line 359 "rl78-decode.opc"
 942                 ID(branch_cond); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(F);
 943
 944               }
 945             break;
 946           case 0x07:
 947               {
 948                 /** 0011 0001 0cnt 0111         shl     %0, %1                          */
 949 #line 1077 "rl78-decode.opc"
 950                 int cnt AU = (op[1] >> 4) & 0x07;
 951                 if (trace)
 952                   {
 953                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 954                            "/** 0011 0001 0cnt 0111             shl     %0, %1                          */",
 955                            op[0], op[1]);
 956                     printf ("  cnt = 0x%x\n", cnt);
 957                   }
 958                 SYNTAX("shl     %0, %1");
 959 #line 1077 "rl78-decode.opc"
 960                 ID(shl); DR(C); SC(cnt);
 961
 962               }
 963             break;
 964           case 0x08:
 965               {
 966                 /** 0011 0001 0cnt 1000         shl     %0, %1                          */
 967 #line 1074 "rl78-decode.opc"
 968                 int cnt AU = (op[1] >> 4) & 0x07;
 969                 if (trace)
 970                   {
 971                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 972                            "/** 0011 0001 0cnt 1000             shl     %0, %1                          */",
 973                            op[0], op[1]);
 974                     printf ("  cnt = 0x%x\n", cnt);
 975                   }
 976                 SYNTAX("shl     %0, %1");
 977 #line 1074 "rl78-decode.opc"
 978                 ID(shl); DR(B); SC(cnt);
 979
 980               }
 981             break;
 982           case 0x09:
 983               {
 984                 /** 0011 0001 0cnt 1001         shl     %0, %1                          */
 985 #line 1071 "rl78-decode.opc"
 986                 int cnt AU = (op[1] >> 4) & 0x07;
 987                 if (trace)
 988                   {
 989                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 990                            "/** 0011 0001 0cnt 1001             shl     %0, %1                          */",
 991                            op[0], op[1]);
 992                     printf ("  cnt = 0x%x\n", cnt);
 993                   }
 994                 SYNTAX("shl     %0, %1");
 995 #line 1071 "rl78-decode.opc"
 996                 ID(shl); DR(A); SC(cnt);
 997
 998               }
 999             break;
1000           case 0x0a:
1001               {
1002                 /** 0011 0001 0cnt 1010         shr     %0, %1                          */
1003 #line 1088 "rl78-decode.opc"
1004                 int cnt AU = (op[1] >> 4) & 0x07;
1005                 if (trace)
1006                   {
1007                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1008                            "/** 0011 0001 0cnt 1010             shr     %0, %1                          */",
1009                            op[0], op[1]);
1010                     printf ("  cnt = 0x%x\n", cnt);
1011                   }
1012                 SYNTAX("shr     %0, %1");
1013 #line 1088 "rl78-decode.opc"
1014                 ID(shr); DR(A); SC(cnt);
1015
1016               }
1017             break;
1018           case 0x0b:
1019               {
1020                 /** 0011 0001 0cnt 1011         sar     %0, %1                          */
1021 #line 1035 "rl78-decode.opc"
1022                 int cnt AU = (op[1] >> 4) & 0x07;
1023                 if (trace)
1024                   {
1025                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1026                            "/** 0011 0001 0cnt 1011             sar     %0, %1                          */",
1027                            op[0], op[1]);
1028                     printf ("  cnt = 0x%x\n", cnt);
1029                   }
1030                 SYNTAX("sar     %0, %1");
1031 #line 1035 "rl78-decode.opc"
1032                 ID(sar); DR(A); SC(cnt);
1033
1034               }
1035             break;
1036           case 0x0c:
1037           case 0x8c:
1038               {
1039                 /** 0011 0001 wcnt 1100         shlw    %0, %1                          */
1040 #line 1083 "rl78-decode.opc"
1041                 int wcnt AU = (op[1] >> 4) & 0x0f;
1042                 if (trace)
1043                   {
1044                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1045                            "/** 0011 0001 wcnt 1100             shlw    %0, %1                          */",
1046                            op[0], op[1]);
1047                     printf ("  wcnt = 0x%x\n", wcnt);
1048                   }
1049                 SYNTAX("shlw    %0, %1");
1050 #line 1083 "rl78-decode.opc"
1051                 ID(shl); W(); DR(BC); SC(wcnt);
1052
1053               /*----------------------------------------------------------------------*/
1054
1055               }
1056             break;
1057           case 0x0d:
1058           case 0x8d:
1059               {
1060                 /** 0011 0001 wcnt 1101         shlw    %0, %1                          */
1061 #line 1080 "rl78-decode.opc"
1062                 int wcnt AU = (op[1] >> 4) & 0x0f;
1063                 if (trace)
1064                   {
1065                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1066                            "/** 0011 0001 wcnt 1101             shlw    %0, %1                          */",
1067                            op[0], op[1]);
1068                     printf ("  wcnt = 0x%x\n", wcnt);
1069                   }
1070                 SYNTAX("shlw    %0, %1");
1071 #line 1080 "rl78-decode.opc"
1072                 ID(shl); W(); DR(AX); SC(wcnt);
1073
1074               }
1075             break;
1076           case 0x0e:
1077           case 0x8e:
1078               {
1079                 /** 0011 0001 wcnt 1110         shrw    %0, %1                          */
1080 #line 1091 "rl78-decode.opc"
1081                 int wcnt AU = (op[1] >> 4) & 0x0f;
1082                 if (trace)
1083                   {
1084                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1085                            "/** 0011 0001 wcnt 1110             shrw    %0, %1                          */",
1086                            op[0], op[1]);
1087                     printf ("  wcnt = 0x%x\n", wcnt);
1088                   }
1089                 SYNTAX("shrw    %0, %1");
1090 #line 1091 "rl78-decode.opc"
1091                 ID(shr); W(); DR(AX); SC(wcnt);
1092
1093               /*----------------------------------------------------------------------*/
1094
1095               }
1096             break;
1097           case 0x0f:
1098           case 0x8f:
1099               {
1100                 /** 0011 0001 wcnt 1111         sarw    %0, %1                          */
1101 #line 1038 "rl78-decode.opc"
1102                 int wcnt AU = (op[1] >> 4) & 0x0f;
1103                 if (trace)
1104                   {
1105                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1106                            "/** 0011 0001 wcnt 1111             sarw    %0, %1                          */",
1107                            op[0], op[1]);
1108                     printf ("  wcnt = 0x%x\n", wcnt);
1109                   }
1110                 SYNTAX("sarw    %0, %1");
1111 #line 1038 "rl78-decode.opc"
1112                 ID(sar); W(); DR(AX); SC(wcnt);
1113
1114               /*----------------------------------------------------------------------*/
1115
1116               }
1117             break;
1118           case 0x80:
1119               {
1120                 /** 0011 0001 1bit 0000         btclr   %s1, $%a0                       */
1121 #line 415 "rl78-decode.opc"
1122                 int bit AU = (op[1] >> 4) & 0x07;
1123                 if (trace)
1124                   {
1125                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1126                            "/** 0011 0001 1bit 0000             btclr   %s1, $%a0                       */",
1127                            op[0], op[1]);
1128                     printf ("  bit = 0x%x\n", bit);
1129                   }
1130                 SYNTAX("btclr   %s1, $%a0");
1131 #line 415 "rl78-decode.opc"
1132                 ID(branch_cond_clear); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
1133
1134               }
1135             break;
1136           case 0x81:
1137               {
1138                 /** 0011 0001 1bit 0001         btclr   %e1, $%a0                       */
1139 #line 409 "rl78-decode.opc"
1140                 int bit AU = (op[1] >> 4) & 0x07;
1141                 if (trace)
1142                   {
1143                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1144                            "/** 0011 0001 1bit 0001             btclr   %e1, $%a0                       */",
1145                            op[0], op[1]);
1146                     printf ("  bit = 0x%x\n", bit);
1147                   }
1148                 SYNTAX("btclr   %e1, $%a0");
1149 #line 409 "rl78-decode.opc"
1150                 ID(branch_cond_clear); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(T);
1151
1152               }
1153             break;
1154           case 0x82:
1155               {
1156                 /** 0011 0001 1bit 0010         bt      %s1, $%a0                       */
1157 #line 401 "rl78-decode.opc"
1158                 int bit AU = (op[1] >> 4) & 0x07;
1159                 if (trace)
1160                   {
1161                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1162                            "/** 0011 0001 1bit 0010             bt      %s1, $%a0                       */",
1163                            op[0], op[1]);
1164                     printf ("  bit = 0x%x\n", bit);
1165                   }
1166                 SYNTAX("bt      %s1, $%a0");
1167 #line 401 "rl78-decode.opc"
1168                 ID(branch_cond); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
1169
1170               }
1171             break;
1172           case 0x83:
1173               {
1174                 /** 0011 0001 1bit 0011         bt      %e1, $%a0                       */
1175 #line 395 "rl78-decode.opc"
1176                 int bit AU = (op[1] >> 4) & 0x07;
1177                 if (trace)
1178                   {
1179                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1180                            "/** 0011 0001 1bit 0011             bt      %e1, $%a0                       */",
1181                            op[0], op[1]);
1182                     printf ("  bit = 0x%x\n", bit);
1183                   }
1184                 SYNTAX("bt      %e1, $%a0");
1185 #line 395 "rl78-decode.opc"
1186                 ID(branch_cond); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(T);
1187
1188               }
1189             break;
1190           case 0x84:
1191               {
1192                 /** 0011 0001 1bit 0100         bf      %s1, $%a0                       */
1193 #line 362 "rl78-decode.opc"
1194                 int bit AU = (op[1] >> 4) & 0x07;
1195                 if (trace)
1196                   {
1197                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1198                            "/** 0011 0001 1bit 0100             bf      %s1, $%a0                       */",
1199                            op[0], op[1]);
1200                     printf ("  bit = 0x%x\n", bit);
1201                   }
1202                 SYNTAX("bf      %s1, $%a0");
1203 #line 362 "rl78-decode.opc"
1204                 ID(branch_cond); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(F);
1205
1206               }
1207             break;
1208           case 0x85:
1209               {
1210                 /** 0011 0001 1bit 0101         bf      %e1, $%a0                       */
1211 #line 356 "rl78-decode.opc"
1212                 int bit AU = (op[1] >> 4) & 0x07;
1213                 if (trace)
1214                   {
1215                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1216                            "/** 0011 0001 1bit 0101             bf      %e1, $%a0                       */",
1217                            op[0], op[1]);
1218                     printf ("  bit = 0x%x\n", bit);
1219                   }
1220                 SYNTAX("bf      %e1, $%a0");
1221 #line 356 "rl78-decode.opc"
1222                 ID(branch_cond); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(F);
1223
1224               }
1225             break;
1226           default: UNSUPPORTED(); break;
1227         }
1228       break;
1229     case 0x33:
1230     case 0x35:
1231     case 0x37:
1232         {
1233           /** 0011 0ra1                 xchw    %0, %1                          */
1234 #line 1241 "rl78-decode.opc"
1235           int ra AU = (op[0] >> 1) & 0x03;
1236           if (trace)
1237             {
1238               printf ("\033[33m%s\033[0m  %02x\n",
1239                      "/** 0011 0ra1                     xchw    %0, %1                          */",
1240                      op[0]);
1241               printf ("  ra = 0x%x\n", ra);
1242             }
1243           SYNTAX("xchw  %0, %1");
1244 #line 1241 "rl78-decode.opc"
1245           ID(xch); W(); DR(AX); SRW(ra);
1246
1247         /*----------------------------------------------------------------------*/
1248
1249         }
1250       break;
1251     case 0x38:
1252         {
1253           /** 0011 1000                 mov     %e0, #%1                        */
1254           if (trace)
1255             {
1256               printf ("\033[33m%s\033[0m  %02x\n",
1257                      "/** 0011 1000                     mov     %e0, #%1                        */",
1258                      op[0]);
1259             }
1260           SYNTAX("mov   %e0, #%1");
1261 #line 740 "rl78-decode.opc"
1262           ID(mov); DM(C, IMMU(2)); SC(IMMU(1));
1263
1264         }
1265       break;
1266     case 0x39:
1267         {
1268           /** 0011 1001                 mov     %e0, #%1                        */
1269           if (trace)
1270             {
1271               printf ("\033[33m%s\033[0m  %02x\n",
1272                      "/** 0011 1001                     mov     %e0, #%1                        */",
1273                      op[0]);
1274             }
1275           SYNTAX("mov   %e0, #%1");
1276 #line 734 "rl78-decode.opc"
1277           ID(mov); DM(BC, IMMU(2)); SC(IMMU(1));
1278
1279         }
1280       break;
1281     case 0x3a:
1282         {
1283           /** 0011 1010                 subc    %0, #%1                         */
1284           if (trace)
1285             {
1286               printf ("\033[33m%s\033[0m  %02x\n",
1287                      "/** 0011 1010                     subc    %0, #%1                         */",
1288                      op[0]);
1289             }
1290           SYNTAX("subc  %0, #%1");
1291 #line 1180 "rl78-decode.opc"
1292           ID(subc); DM(None, SADDR); SC(IMMU(1)); Fzac;
1293
1294         /*----------------------------------------------------------------------*/
1295
1296         }
1297       break;
1298     case 0x3b:
1299         {
1300           /** 0011 1011                 subc    %0, %1                          */
1301           if (trace)
1302             {
1303               printf ("\033[33m%s\033[0m  %02x\n",
1304                      "/** 0011 1011                     subc    %0, %1                          */",
1305                      op[0]);
1306             }
1307           SYNTAX("subc  %0, %1");
1308 #line 1177 "rl78-decode.opc"
1309           ID(subc); DR(A); SM(None, SADDR); Fzac;
1310
1311         }
1312       break;
1313     case 0x3c:
1314         {
1315           /** 0011 1100                 subc    %0, #%1                         */
1316           if (trace)
1317             {
1318               printf ("\033[33m%s\033[0m  %02x\n",
1319                      "/** 0011 1100                     subc    %0, #%1                         */",
1320                      op[0]);
1321             }
1322           SYNTAX("subc  %0, #%1");
1323 #line 1168 "rl78-decode.opc"
1324           ID(subc); DR(A); SC(IMMU(1)); Fzac;
1325
1326         }
1327       break;
1328     case 0x3d:
1329         {
1330           /** 0011 1101                 subc    %0, %e1                         */
1331           if (trace)
1332             {
1333               printf ("\033[33m%s\033[0m  %02x\n",
1334                      "/** 0011 1101                     subc    %0, %e1                         */",
1335                      op[0]);
1336             }
1337           SYNTAX("subc  %0, %e1");
1338 #line 1156 "rl78-decode.opc"
1339           ID(subc); DR(A); SM(HL, 0); Fzac;
1340
1341         }
1342       break;
1343     case 0x3e:
1344         {
1345           /** 0011 1110                 subc    %0, %ea1                        */
1346           if (trace)
1347             {
1348               printf ("\033[33m%s\033[0m  %02x\n",
1349                      "/** 0011 1110                     subc    %0, %ea1                        */",
1350                      op[0]);
1351             }
1352           SYNTAX("subc  %0, %ea1");
1353 #line 1165 "rl78-decode.opc"
1354           ID(subc); DR(A); SM(HL, IMMU(1)); Fzac;
1355
1356         }
1357       break;
1358     case 0x3f:
1359         {
1360           /** 0011 1111                 subc    %0, %e!1                        */
1361           if (trace)
1362             {
1363               printf ("\033[33m%s\033[0m  %02x\n",
1364                      "/** 0011 1111                     subc    %0, %e!1                        */",
1365                      op[0]);
1366             }
1367           SYNTAX("subc  %0, %e!1");
1368 #line 1153 "rl78-decode.opc"
1369           ID(subc); DR(A); SM(None, IMMU(2)); Fzac;
1370
1371         }
1372       break;
1373     case 0x40:
1374         {
1375           /** 0100 0000                 cmp     %e!0, #%1                       */
1376           if (trace)
1377             {
1378               printf ("\033[33m%s\033[0m  %02x\n",
1379                      "/** 0100 0000                     cmp     %e!0, #%1                       */",
1380                      op[0]);
1381             }
1382           SYNTAX("cmp   %e!0, #%1");
1383 #line 482 "rl78-decode.opc"
1384           ID(cmp); DM(None, IMMU(2)); SC(IMMU(1)); Fzac;
1385
1386         }
1387       break;
1388     case 0x41:
1389         {
1390           /** 0100 0001                 mov     %0, #%1                         */
1391           if (trace)
1392             {
1393               printf ("\033[33m%s\033[0m  %02x\n",
1394                      "/** 0100 0001                     mov     %0, #%1                         */",
1395                      op[0]);
1396             }
1397           SYNTAX("mov   %0, #%1");
1398 #line 719 "rl78-decode.opc"
1399           ID(mov); DR(ES); SC(IMMU(1));
1400
1401         }
1402       break;
1403     case 0x42:
1404         {
1405           /** 0100 0010                 cmpw    %0, %e!1                        */
1406           if (trace)
1407             {
1408               printf ("\033[33m%s\033[0m  %02x\n",
1409                      "/** 0100 0010                     cmpw    %0, %e!1                        */",
1410                      op[0]);
1411             }
1412           SYNTAX("cmpw  %0, %e!1");
1413 #line 533 "rl78-decode.opc"
1414           ID(cmp); W(); DR(AX); SM(None, IMMU(2)); Fzac;
1415
1416         }
1417       break;
1418     case 0x43:
1419     case 0x45:
1420     case 0x47:
1421         {
1422           /** 0100 0ra1                 cmpw    %0, %1                          */
1423 #line 542 "rl78-decode.opc"
1424           int ra AU = (op[0] >> 1) & 0x03;
1425           if (trace)
1426             {
1427               printf ("\033[33m%s\033[0m  %02x\n",
1428                      "/** 0100 0ra1                     cmpw    %0, %1                          */",
1429                      op[0]);
1430               printf ("  ra = 0x%x\n", ra);
1431             }
1432           SYNTAX("cmpw  %0, %1");
1433 #line 542 "rl78-decode.opc"
1434           ID(cmp); W(); DR(AX); SRW(ra); Fzac;
1435
1436         }
1437       break;
1438     case 0x44:
1439         {
1440           /** 0100 0100                 cmpw    %0, #%1                         */
1441           if (trace)
1442             {
1443               printf ("\033[33m%s\033[0m  %02x\n",
1444                      "/** 0100 0100                     cmpw    %0, #%1                         */",
1445                      op[0]);
1446             }
1447           SYNTAX("cmpw  %0, #%1");
1448 #line 539 "rl78-decode.opc"
1449           ID(cmp); W(); DR(AX); SC(IMMU(2)); Fzac;
1450
1451         }
1452       break;
1453     case 0x46:
1454         {
1455           /** 0100 0110                 cmpw    %0, %1                          */
1456           if (trace)
1457             {
1458               printf ("\033[33m%s\033[0m  %02x\n",
1459                      "/** 0100 0110                     cmpw    %0, %1                          */",
1460                      op[0]);
1461             }
1462           SYNTAX("cmpw  %0, %1");
1463 #line 545 "rl78-decode.opc"
1464           ID(cmp); W(); DR(AX); SM(None, SADDR); Fzac;
1465
1466         /*----------------------------------------------------------------------*/
1467
1468         }
1469       break;
1470     case 0x48:
1471         {
1472           /** 0100 1000                 mov     %e0, %1                         */
1473           if (trace)
1474             {
1475               printf ("\033[33m%s\033[0m  %02x\n",
1476                      "/** 0100 1000                     mov     %e0, %1                         */",
1477                      op[0]);
1478             }
1479           SYNTAX("mov   %e0, %1");
1480 #line 737 "rl78-decode.opc"
1481           ID(mov); DM(BC, IMMU(2)); SR(A);
1482
1483         }
1484       break;
1485     case 0x49:
1486         {
1487           /** 0100 1001                 mov     %0, %e1                         */
1488           if (trace)
1489             {
1490               printf ("\033[33m%s\033[0m  %02x\n",
1491                      "/** 0100 1001                     mov     %0, %e1                         */",
1492                      op[0]);
1493             }
1494           SYNTAX("mov   %0, %e1");
1495 #line 683 "rl78-decode.opc"
1496           ID(mov); DR(A); SM(BC, IMMU(2));
1497
1498         }
1499       break;
1500     case 0x4a:
1501         {
1502           /** 0100 1010                 cmp     %0, #%1                         */
1503           if (trace)
1504             {
1505               printf ("\033[33m%s\033[0m  %02x\n",
1506                      "/** 0100 1010                     cmp     %0, #%1                         */",
1507                      op[0]);
1508             }
1509           SYNTAX("cmp   %0, #%1");
1510 #line 485 "rl78-decode.opc"
1511           ID(cmp); DM(None, SADDR); SC(IMMU(1)); Fzac;
1512
1513         }
1514       break;
1515     case 0x4b:
1516         {
1517           /** 0100 1011                 cmp     %0, %1                          */
1518           if (trace)
1519             {
1520               printf ("\033[33m%s\033[0m  %02x\n",
1521                      "/** 0100 1011                     cmp     %0, %1                          */",
1522                      op[0]);
1523             }
1524           SYNTAX("cmp   %0, %1");
1525 #line 512 "rl78-decode.opc"
1526           ID(cmp); DR(A); SM(None, SADDR); Fzac;
1527
1528         /*----------------------------------------------------------------------*/
1529
1530         }
1531       break;
1532     case 0x4c:
1533         {
1534           /** 0100 1100                 cmp     %0, #%1                         */
1535           if (trace)
1536             {
1537               printf ("\033[33m%s\033[0m  %02x\n",
1538                      "/** 0100 1100                     cmp     %0, #%1                         */",
1539                      op[0]);
1540             }
1541           SYNTAX("cmp   %0, #%1");
1542 #line 503 "rl78-decode.opc"
1543           ID(cmp); DR(A); SC(IMMU(1)); Fzac;
1544
1545         }
1546       break;
1547     case 0x4d:
1548         {
1549           /** 0100 1101                 cmp     %0, %e1                         */
1550           if (trace)
1551             {
1552               printf ("\033[33m%s\033[0m  %02x\n",
1553                      "/** 0100 1101                     cmp     %0, %e1                         */",
1554                      op[0]);
1555             }
1556           SYNTAX("cmp   %0, %e1");
1557 #line 491 "rl78-decode.opc"
1558           ID(cmp); DR(A); SM(HL, 0); Fzac;
1559
1560         }
1561       break;
1562     case 0x4e:
1563         {
1564           /** 0100 1110                 cmp     %0, %ea1                        */
1565           if (trace)
1566             {
1567               printf ("\033[33m%s\033[0m  %02x\n",
1568                      "/** 0100 1110                     cmp     %0, %ea1                        */",
1569                      op[0]);
1570             }
1571           SYNTAX("cmp   %0, %ea1");
1572 #line 500 "rl78-decode.opc"
1573           ID(cmp); DR(A); SM(HL, IMMU(1)); Fzac;
1574
1575         }
1576       break;
1577     case 0x4f:
1578         {
1579           /** 0100 1111                 cmp     %0, %e!1                        */
1580           if (trace)
1581             {
1582               printf ("\033[33m%s\033[0m  %02x\n",
1583                      "/** 0100 1111                     cmp     %0, %e!1                        */",
1584                      op[0]);
1585             }
1586           SYNTAX("cmp   %0, %e!1");
1587 #line 488 "rl78-decode.opc"
1588           ID(cmp); DR(A); SM(None, IMMU(2)); Fzac;
1589
1590         }
1591       break;
1592     case 0x50:
1593     case 0x51:
1594     case 0x52:
1595     case 0x53:
1596     case 0x54:
1597     case 0x55:
1598     case 0x56:
1599     case 0x57:
1600         {
1601           /** 0101 0reg                 mov     %0, #%1                         */
1602 #line 671 "rl78-decode.opc"
1603           int reg AU = op[0] & 0x07;
1604           if (trace)
1605             {
1606               printf ("\033[33m%s\033[0m  %02x\n",
1607                      "/** 0101 0reg                     mov     %0, #%1                         */",
1608                      op[0]);
1609               printf ("  reg = 0x%x\n", reg);
1610             }
1611           SYNTAX("mov   %0, #%1");
1612 #line 671 "rl78-decode.opc"
1613           ID(mov); DRB(reg); SC(IMMU(1));
1614
1615         }
1616       break;
1617     case 0x58:
1618         {
1619           /** 0101 1000                 movw    %e0, %1                         */
1620           if (trace)
1621             {
1622               printf ("\033[33m%s\033[0m  %02x\n",
1623                      "/** 0101 1000                     movw    %e0, %1                         */",
1624                      op[0]);
1625             }
1626           SYNTAX("movw  %e0, %1");
1627 #line 873 "rl78-decode.opc"
1628           ID(mov); W(); DM(B, IMMU(2)); SR(AX);
1629
1630         }
1631       break;
1632     case 0x59:
1633         {
1634           /** 0101 1001                 movw    %0, %e1                         */
1635           if (trace)
1636             {
1637               printf ("\033[33m%s\033[0m  %02x\n",
1638                      "/** 0101 1001                     movw    %0, %e1                         */",
1639                      op[0]);
1640             }
1641           SYNTAX("movw  %0, %e1");
1642 #line 864 "rl78-decode.opc"
1643           ID(mov); W(); DR(AX); SM(B, IMMU(2));
1644
1645         }
1646       break;
1647     case 0x5a:
1648         {
1649           /** 0101 1010                 and     %0, #%1                         */
1650           if (trace)
1651             {
1652               printf ("\033[33m%s\033[0m  %02x\n",
1653                      "/** 0101 1010                     and     %0, #%1                         */",
1654                      op[0]);
1655             }
1656           SYNTAX("and   %0, #%1");
1657 #line 314 "rl78-decode.opc"
1658           ID(and); DM(None, SADDR); SC(IMMU(1)); Fz;
1659
1660         /*----------------------------------------------------------------------*/
1661
1662         }
1663       break;
1664     case 0x5b:
1665         {
1666           /** 0101 1011                 and     %0, %1                          */
1667           if (trace)
1668             {
1669               printf ("\033[33m%s\033[0m  %02x\n",
1670                      "/** 0101 1011                     and     %0, %1                          */",
1671                      op[0]);
1672             }
1673           SYNTAX("and   %0, %1");
1674 #line 311 "rl78-decode.opc"
1675           ID(and); DR(A); SM(None, SADDR); Fz;
1676
1677         }
1678       break;
1679     case 0x5c:
1680         {
1681           /** 0101 1100                 and     %0, #%1                         */
1682           if (trace)
1683             {
1684               printf ("\033[33m%s\033[0m  %02x\n",
1685                      "/** 0101 1100                     and     %0, #%1                         */",
1686                      op[0]);
1687             }
1688           SYNTAX("and   %0, #%1");
1689 #line 302 "rl78-decode.opc"
1690           ID(and); DR(A); SC(IMMU(1)); Fz;
1691
1692         }
1693       break;
1694     case 0x5d:
1695         {
1696           /** 0101 1101                 and     %0, %e1                 */
1697           if (trace)
1698             {
1699               printf ("\033[33m%s\033[0m  %02x\n",
1700                      "/** 0101 1101                     and     %0, %e1                 */",
1701                      op[0]);
1702             }
1703           SYNTAX("and   %0, %e1");
1704 #line 290 "rl78-decode.opc"
1705           ID(and); DR(A); SM(HL, 0); Fz;
1706
1707         }
1708       break;
1709     case 0x5e:
1710         {
1711           /** 0101 1110                 and     %0, %ea1                        */
1712           if (trace)
1713             {
1714               printf ("\033[33m%s\033[0m  %02x\n",
1715                      "/** 0101 1110                     and     %0, %ea1                        */",
1716                      op[0]);
1717             }
1718           SYNTAX("and   %0, %ea1");
1719 #line 296 "rl78-decode.opc"
1720           ID(and); DR(A); SM(HL, IMMU(1)); Fz;
1721
1722         }
1723       break;
1724     case 0x5f:
1725         {
1726           /** 0101 1111                 and     %0, %e!1                        */
1727           if (trace)
1728             {
1729               printf ("\033[33m%s\033[0m  %02x\n",
1730                      "/** 0101 1111                     and     %0, %e!1                        */",
1731                      op[0]);
1732             }
1733           SYNTAX("and   %0, %e!1");
1734 #line 287 "rl78-decode.opc"
1735           ID(and); DR(A); SM(None, IMMU(2)); Fz;
1736
1737         }
1738       break;
1739     case 0x60:
1740     case 0x62:
1741     case 0x63:
1742     case 0x64:
1743     case 0x65:
1744     case 0x66:
1745     case 0x67:
1746         {
1747           /** 0110 0rba                 mov     %0, %1                          */
1748 #line 674 "rl78-decode.opc"
1749           int rba AU = op[0] & 0x07;
1750           if (trace)
1751             {
1752               printf ("\033[33m%s\033[0m  %02x\n",
1753                      "/** 0110 0rba                     mov     %0, %1                          */",
1754                      op[0]);
1755               printf ("  rba = 0x%x\n", rba);
1756             }
1757           SYNTAX("mov   %0, %1");
1758 #line 674 "rl78-decode.opc"
1759           ID(mov); DR(A); SRB(rba);
1760
1761         }
1762       break;
1763     case 0x61:
1764         GETBYTE ();
1765         switch (op[1] & 0xff)
1766         {
1767           case 0x00:
1768           case 0x01:
1769           case 0x02:
1770           case 0x03:
1771           case 0x04:
1772           case 0x05:
1773           case 0x06:
1774           case 0x07:
1775               {
1776                 /** 0110 0001 0000 0reg         add     %0, %1                          */
1777 #line 227 "rl78-decode.opc"
1778                 int reg AU = op[1] & 0x07;
1779                 if (trace)
1780                   {
1781                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1782                            "/** 0110 0001 0000 0reg             add     %0, %1                          */",
1783                            op[0], op[1]);
1784                     printf ("  reg = 0x%x\n", reg);
1785                   }
1786                 SYNTAX("add     %0, %1");
1787 #line 227 "rl78-decode.opc"
1788                 ID(add); DRB(reg); SR(A); Fzac;
1789
1790               }
1791             break;
1792           case 0x08:
1793           case 0x0a:
1794           case 0x0b:
1795           case 0x0c:
1796           case 0x0d:
1797           case 0x0e:
1798           case 0x0f:
1799               {
1800                 /** 0110 0001 0000 1rba         add     %0, %1                          */
1801 #line 221 "rl78-decode.opc"
1802                 int rba AU = op[1] & 0x07;
1803                 if (trace)
1804                   {
1805                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1806                            "/** 0110 0001 0000 1rba             add     %0, %1                          */",
1807                            op[0], op[1]);
1808                     printf ("  rba = 0x%x\n", rba);
1809                   }
1810                 SYNTAX("add     %0, %1");
1811 #line 221 "rl78-decode.opc"
1812                 ID(add); DR(A); SRB(rba); Fzac;
1813
1814               }
1815             break;
1816           case 0x09:
1817               {
1818                 /** 0110 0001 0000 1001         addw    %0, %ea1                        */
1819                 if (trace)
1820                   {
1821                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1822                            "/** 0110 0001 0000 1001             addw    %0, %ea1                        */",
1823                            op[0], op[1]);
1824                   }
1825                 SYNTAX("addw    %0, %ea1");
1826 #line 270 "rl78-decode.opc"
1827                 ID(add); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
1828
1829               }
1830             break;
1831           case 0x10:
1832           case 0x11:
1833           case 0x12:
1834           case 0x13:
1835           case 0x14:
1836           case 0x15:
1837           case 0x16:
1838           case 0x17:
1839               {
1840                 /** 0110 0001 0001 0reg         addc    %0, %1                          */
1841 #line 256 "rl78-decode.opc"
1842                 int reg AU = op[1] & 0x07;
1843                 if (trace)
1844                   {
1845                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1846                            "/** 0110 0001 0001 0reg             addc    %0, %1                          */",
1847                            op[0], op[1]);
1848                     printf ("  reg = 0x%x\n", reg);
1849                   }
1850                 SYNTAX("addc    %0, %1");
1851 #line 256 "rl78-decode.opc"
1852                 ID(addc); DRB(reg); SR(A); Fzac;
1853
1854               }
1855             break;
1856           case 0x18:
1857           case 0x1a:
1858           case 0x1b:
1859           case 0x1c:
1860           case 0x1d:
1861           case 0x1e:
1862           case 0x1f:
1863               {
1864                 /** 0110 0001 0001 1rba         addc    %0, %1                          */
1865 #line 253 "rl78-decode.opc"
1866                 int rba AU = op[1] & 0x07;
1867                 if (trace)
1868                   {
1869                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1870                            "/** 0110 0001 0001 1rba             addc    %0, %1                          */",
1871                            op[0], op[1]);
1872                     printf ("  rba = 0x%x\n", rba);
1873                   }
1874                 SYNTAX("addc    %0, %1");
1875 #line 253 "rl78-decode.opc"
1876                 ID(addc); DR(A); SRB(rba); Fzac;
1877
1878               }
1879             break;
1880           case 0x20:
1881           case 0x21:
1882           case 0x22:
1883           case 0x23:
1884           case 0x24:
1885           case 0x25:
1886           case 0x26:
1887           case 0x27:
1888               {
1889                 /** 0110 0001 0010 0reg         sub     %0, %1                          */
1890 #line 1145 "rl78-decode.opc"
1891                 int reg AU = op[1] & 0x07;
1892                 if (trace)
1893                   {
1894                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1895                            "/** 0110 0001 0010 0reg             sub     %0, %1                          */",
1896                            op[0], op[1]);
1897                     printf ("  reg = 0x%x\n", reg);
1898                   }
1899                 SYNTAX("sub     %0, %1");
1900 #line 1145 "rl78-decode.opc"
1901                 ID(sub); DRB(reg); SR(A); Fzac;
1902
1903               }
1904             break;
1905           case 0x28:
1906           case 0x2a:
1907           case 0x2b:
1908           case 0x2c:
1909           case 0x2d:
1910           case 0x2e:
1911           case 0x2f:
1912               {
1913                 /** 0110 0001 0010 1rba         sub     %0, %1                          */
1914 #line 1139 "rl78-decode.opc"
1915                 int rba AU = op[1] & 0x07;
1916                 if (trace)
1917                   {
1918                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1919                            "/** 0110 0001 0010 1rba             sub     %0, %1                          */",
1920                            op[0], op[1]);
1921                     printf ("  rba = 0x%x\n", rba);
1922                   }
1923                 SYNTAX("sub     %0, %1");
1924 #line 1139 "rl78-decode.opc"
1925                 ID(sub); DR(A); SRB(rba); Fzac;
1926
1927               }
1928             break;
1929           case 0x29:
1930               {
1931                 /** 0110 0001 0010 1001         subw    %0, %ea1                        */
1932                 if (trace)
1933                   {
1934                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1935                            "/** 0110 0001 0010 1001             subw    %0, %ea1                        */",
1936                            op[0], op[1]);
1937                   }
1938                 SYNTAX("subw    %0, %ea1");
1939 #line 1188 "rl78-decode.opc"
1940                 ID(sub); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
1941
1942               }
1943             break;
1944           case 0x30:
1945           case 0x31:
1946           case 0x32:
1947           case 0x33:
1948           case 0x34:
1949           case 0x35:
1950           case 0x36:
1951           case 0x37:
1952               {
1953                 /** 0110 0001 0011 0reg         subc    %0, %1                          */
1954 #line 1174 "rl78-decode.opc"
1955                 int reg AU = op[1] & 0x07;
1956                 if (trace)
1957                   {
1958                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1959                            "/** 0110 0001 0011 0reg             subc    %0, %1                          */",
1960                            op[0], op[1]);
1961                     printf ("  reg = 0x%x\n", reg);
1962                   }
1963                 SYNTAX("subc    %0, %1");
1964 #line 1174 "rl78-decode.opc"
1965                 ID(subc); DRB(reg); SR(A); Fzac;
1966
1967               }
1968             break;
1969           case 0x38:
1970           case 0x3a:
1971           case 0x3b:
1972           case 0x3c:
1973           case 0x3d:
1974           case 0x3e:
1975           case 0x3f:
1976               {
1977                 /** 0110 0001 0011 1rba         subc    %0, %1                          */
1978 #line 1171 "rl78-decode.opc"
1979                 int rba AU = op[1] & 0x07;
1980                 if (trace)
1981                   {
1982                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1983                            "/** 0110 0001 0011 1rba             subc    %0, %1                          */",
1984                            op[0], op[1]);
1985                     printf ("  rba = 0x%x\n", rba);
1986                   }
1987                 SYNTAX("subc    %0, %1");
1988 #line 1171 "rl78-decode.opc"
1989                 ID(subc); DR(A); SRB(rba); Fzac;
1990
1991               }
1992             break;
1993           case 0x40:
1994           case 0x41:
1995           case 0x42:
1996           case 0x43:
1997           case 0x44:
1998           case 0x45:
1999           case 0x46:
2000           case 0x47:
2001               {
2002                 /** 0110 0001 0100 0reg         cmp     %0, %1                          */
2003 #line 509 "rl78-decode.opc"
2004                 int reg AU = op[1] & 0x07;
2005                 if (trace)
2006                   {
2007                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2008                            "/** 0110 0001 0100 0reg             cmp     %0, %1                          */",
2009                            op[0], op[1]);
2010                     printf ("  reg = 0x%x\n", reg);
2011                   }
2012                 SYNTAX("cmp     %0, %1");
2013 #line 509 "rl78-decode.opc"
2014                 ID(cmp); DRB(reg); SR(A); Fzac;
2015
2016               }
2017             break;
2018           case 0x48:
2019           case 0x4a:
2020           case 0x4b:
2021           case 0x4c:
2022           case 0x4d:
2023           case 0x4e:
2024           case 0x4f:
2025               {
2026                 /** 0110 0001 0100 1rba         cmp     %0, %1                          */
2027 #line 506 "rl78-decode.opc"
2028                 int rba AU = op[1] & 0x07;
2029                 if (trace)
2030                   {
2031                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2032                            "/** 0110 0001 0100 1rba             cmp     %0, %1                          */",
2033                            op[0], op[1]);
2034                     printf ("  rba = 0x%x\n", rba);
2035                   }
2036                 SYNTAX("cmp     %0, %1");
2037 #line 506 "rl78-decode.opc"
2038                 ID(cmp); DR(A); SRB(rba); Fzac;
2039
2040               }
2041             break;
2042           case 0x49:
2043               {
2044                 /** 0110 0001 0100 1001         cmpw    %0, %ea1                        */
2045                 if (trace)
2046                   {
2047                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2048                            "/** 0110 0001 0100 1001             cmpw    %0, %ea1                        */",
2049                            op[0], op[1]);
2050                   }
2051                 SYNTAX("cmpw    %0, %ea1");
2052 #line 536 "rl78-decode.opc"
2053                 ID(cmp); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
2054
2055               }
2056             break;
2057           case 0x50:
2058           case 0x51:
2059           case 0x52:
2060           case 0x53:
2061           case 0x54:
2062           case 0x55:
2063           case 0x56:
2064           case 0x57:
2065               {
2066                 /** 0110 0001 0101 0reg         and     %0, %1                          */
2067 #line 308 "rl78-decode.opc"
2068                 int reg AU = op[1] & 0x07;
2069                 if (trace)
2070                   {
2071                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2072                            "/** 0110 0001 0101 0reg             and     %0, %1                          */",
2073                            op[0], op[1]);
2074                     printf ("  reg = 0x%x\n", reg);
2075                   }
2076                 SYNTAX("and     %0, %1");
2077 #line 308 "rl78-decode.opc"
2078                 ID(and); DRB(reg); SR(A); Fz;
2079
2080               }
2081             break;
2082           case 0x58:
2083           case 0x5a:
2084           case 0x5b:
2085           case 0x5c:
2086           case 0x5d:
2087           case 0x5e:
2088           case 0x5f:
2089               {
2090                 /** 0110 0001 0101 1rba         and     %0, %1                          */
2091 #line 305 "rl78-decode.opc"
2092                 int rba AU = op[1] & 0x07;
2093                 if (trace)
2094                   {
2095                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2096                            "/** 0110 0001 0101 1rba             and     %0, %1                          */",
2097                            op[0], op[1]);
2098                     printf ("  rba = 0x%x\n", rba);
2099                   }
2100                 SYNTAX("and     %0, %1");
2101 #line 305 "rl78-decode.opc"
2102                 ID(and); DR(A); SRB(rba); Fz;
2103
2104               }
2105             break;
2106           case 0x59:
2107               {
2108                 /** 0110 0001 0101 1001         inc     %ea0                            */
2109                 if (trace)
2110                   {
2111                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2112                            "/** 0110 0001 0101 1001             inc     %ea0                            */",
2113                            op[0], op[1]);
2114                   }
2115                 SYNTAX("inc     %ea0");
2116 #line 586 "rl78-decode.opc"
2117                 ID(add); DM(HL, IMMU(1)); SC(1); Fza;
2118
2119               }
2120             break;
2121           case 0x60:
2122           case 0x61:
2123           case 0x62:
2124           case 0x63:
2125           case 0x64:
2126           case 0x65:
2127           case 0x66:
2128           case 0x67:
2129               {
2130                 /** 0110 0001 0110 0reg         or      %0, %1                          */
2131 #line 963 "rl78-decode.opc"
2132                 int reg AU = op[1] & 0x07;
2133                 if (trace)
2134                   {
2135                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2136                            "/** 0110 0001 0110 0reg             or      %0, %1                          */",
2137                            op[0], op[1]);
2138                     printf ("  reg = 0x%x\n", reg);
2139                   }
2140                 SYNTAX("or      %0, %1");
2141 #line 963 "rl78-decode.opc"
2142                 ID(or); DRB(reg); SR(A); Fz;
2143
2144               }
2145             break;
2146           case 0x68:
2147           case 0x6a:
2148           case 0x6b:
2149           case 0x6c:
2150           case 0x6d:
2151           case 0x6e:
2152           case 0x6f:
2153               {
2154                 /** 0110 0001 0110 1rba         or      %0, %1                          */
2155 #line 960 "rl78-decode.opc"
2156                 int rba AU = op[1] & 0x07;
2157                 if (trace)
2158                   {
2159                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2160                            "/** 0110 0001 0110 1rba             or      %0, %1                          */",
2161                            op[0], op[1]);
2162                     printf ("  rba = 0x%x\n", rba);
2163                   }
2164                 SYNTAX("or      %0, %1");
2165 #line 960 "rl78-decode.opc"
2166                 ID(or); DR(A); SRB(rba); Fz;
2167
2168               }
2169             break;
2170           case 0x69:
2171               {
2172                 /** 0110 0001 0110 1001         dec     %ea0                            */
2173                 if (trace)
2174                   {
2175                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2176                            "/** 0110 0001 0110 1001             dec     %ea0                            */",
2177                            op[0], op[1]);
2178                   }
2179                 SYNTAX("dec     %ea0");
2180 #line 553 "rl78-decode.opc"
2181                 ID(sub); DM(HL, IMMU(1)); SC(1); Fza;
2182
2183               }
2184             break;
2185           case 0x70:
2186           case 0x71:
2187           case 0x72:
2188           case 0x73:
2189           case 0x74:
2190           case 0x75:
2191           case 0x76:
2192           case 0x77:
2193               {
2194                 /** 0110 0001 0111 0reg         xor     %0, %1                          */
2195 #line 1267 "rl78-decode.opc"
2196                 int reg AU = op[1] & 0x07;
2197                 if (trace)
2198                   {
2199                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2200                            "/** 0110 0001 0111 0reg             xor     %0, %1                          */",
2201                            op[0], op[1]);
2202                     printf ("  reg = 0x%x\n", reg);
2203                   }
2204                 SYNTAX("xor     %0, %1");
2205 #line 1267 "rl78-decode.opc"
2206                 ID(xor); DRB(reg); SR(A); Fz;
2207
2208               }
2209             break;
2210           case 0x78:
2211           case 0x7a:
2212           case 0x7b:
2213           case 0x7c:
2214           case 0x7d:
2215           case 0x7e:
2216           case 0x7f:
2217               {
2218                 /** 0110 0001 0111 1rba         xor     %0, %1                          */
2219 #line 1264 "rl78-decode.opc"
2220                 int rba AU = op[1] & 0x07;
2221                 if (trace)
2222                   {
2223                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2224                            "/** 0110 0001 0111 1rba             xor     %0, %1                          */",
2225                            op[0], op[1]);
2226                     printf ("  rba = 0x%x\n", rba);
2227                   }
2228                 SYNTAX("xor     %0, %1");
2229 #line 1264 "rl78-decode.opc"
2230                 ID(xor); DR(A); SRB(rba); Fz;
2231
2232               }
2233             break;
2234           case 0x79:
2235               {
2236                 /** 0110 0001 0111 1001         incw    %ea0                            */
2237                 if (trace)
2238                   {
2239                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2240                            "/** 0110 0001 0111 1001             incw    %ea0                            */",
2241                            op[0], op[1]);
2242                   }
2243                 SYNTAX("incw    %ea0");
2244 #line 600 "rl78-decode.opc"
2245                 ID(add); W(); DM(HL, IMMU(1)); SC(1);
2246
2247               }
2248             break;
2249           case 0x80:
2250           case 0x81:
2251               {
2252                 /** 0110 0001 1000 000          add     %0, %e1                         */
2253                 if (trace)
2254                   {
2255                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2256                            "/** 0110 0001 1000 000              add     %0, %e1                         */",
2257                            op[0], op[1]);
2258                   }
2259                 SYNTAX("add     %0, %e1");
2260 #line 209 "rl78-decode.opc"
2261                 ID(add); DR(A); SM2(HL, B, 0); Fzac;
2262
2263               }
2264             break;
2265           case 0x82:
2266               {
2267                 /** 0110 0001 1000 0010         add     %0, %e1                         */
2268                 if (trace)
2269                   {
2270                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2271                            "/** 0110 0001 1000 0010             add     %0, %e1                         */",
2272                            op[0], op[1]);
2273                   }
2274                 SYNTAX("add     %0, %e1");
2275 #line 215 "rl78-decode.opc"
2276                 ID(add); DR(A); SM2(HL, C, 0); Fzac;
2277
2278               }
2279             break;
2280           case 0x84:
2281           case 0x85:
2282           case 0x86:
2283           case 0x87:
2284           case 0x94:
2285           case 0x95:
2286           case 0x96:
2287           case 0x97:
2288           case 0xa4:
2289           case 0xa5:
2290           case 0xa6:
2291           case 0xa7:
2292           case 0xb4:
2293           case 0xb5:
2294           case 0xb6:
2295           case 0xb7:
2296           case 0xc4:
2297           case 0xc5:
2298           case 0xc6:
2299           case 0xc7:
2300           case 0xd4:
2301           case 0xd5:
2302           case 0xd6:
2303           case 0xd7:
2304           case 0xe4:
2305           case 0xe5:
2306           case 0xe6:
2307           case 0xe7:
2308           case 0xf4:
2309           case 0xf5:
2310           case 0xf6:
2311           case 0xf7:
2312               {
2313                 /** 0110 0001 1nnn 01mm         callt   [%x0]                           */
2314 #line 435 "rl78-decode.opc"
2315                 int nnn AU = (op[1] >> 4) & 0x07;
2316 #line 435 "rl78-decode.opc"
2317                 int mm AU = op[1] & 0x03;
2318                 if (trace)
2319                   {
2320                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2321                            "/** 0110 0001 1nnn 01mm             callt   [%x0]                           */",
2322                            op[0], op[1]);
2323                     printf ("  nnn = 0x%x,", nnn);
2324                     printf ("  mm = 0x%x\n", mm);
2325                   }
2326                 SYNTAX("callt   [%x0]");
2327 #line 435 "rl78-decode.opc"
2328                 ID(call); DM(None, 0x80 + mm*16 + nnn*2);
2329
2330               /*----------------------------------------------------------------------*/
2331
2332               }
2333             break;
2334           case 0x88:
2335           case 0x8a:
2336           case 0x8b:
2337           case 0x8c:
2338           case 0x8d:
2339           case 0x8e:
2340           case 0x8f:
2341               {
2342                 /** 0110 0001 1000 1reg         xch     %0, %1                          */
2343 #line 1226 "rl78-decode.opc"
2344                 int reg AU = op[1] & 0x07;
2345                 if (trace)
2346                   {
2347                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2348                            "/** 0110 0001 1000 1reg             xch     %0, %1                          */",
2349                            op[0], op[1]);
2350                     printf ("  reg = 0x%x\n", reg);
2351                   }
2352                 SYNTAX("xch     %0, %1");
2353 #line 1226 "rl78-decode.opc"
2354                 /* Note: DECW uses reg == X, so this must follow DECW */
2355                 ID(xch); DR(A); SRB(reg);
2356
2357               }
2358             break;
2359           case 0x89:
2360               {
2361                 /** 0110 0001 1000 1001         decw    %ea0                            */
2362                 if (trace)
2363                   {
2364                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2365                            "/** 0110 0001 1000 1001             decw    %ea0                            */",
2366                            op[0], op[1]);
2367                   }
2368                 SYNTAX("decw    %ea0");
2369 #line 567 "rl78-decode.opc"
2370                 ID(sub); W(); DM(HL, IMMU(1)); SC(1);
2371
2372               }
2373             break;
2374           case 0x90:
2375               {
2376                 /** 0110 0001 1001 0000         addc    %0, %e1                         */
2377                 if (trace)
2378                   {
2379                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2380                            "/** 0110 0001 1001 0000             addc    %0, %e1                         */",
2381                            op[0], op[1]);
2382                   }
2383                 SYNTAX("addc    %0, %e1");
2384 #line 241 "rl78-decode.opc"
2385                 ID(addc); DR(A); SM2(HL, B, 0); Fzac;
2386
2387               }
2388             break;
2389           case 0x92:
2390               {
2391                 /** 0110 0001 1001 0010         addc    %0, %e1                         */
2392                 if (trace)
2393                   {
2394                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2395                            "/** 0110 0001 1001 0010             addc    %0, %e1                         */",
2396                            op[0], op[1]);
2397                   }
2398                 SYNTAX("addc    %0, %e1");
2399 #line 244 "rl78-decode.opc"
2400                 ID(addc); DR(A); SM2(HL, C, 0); Fzac;
2401
2402               }
2403             break;
2404           case 0xa0:
2405           case 0xa1:
2406               {
2407                 /** 0110 0001 1010 000          sub     %0, %e1                         */
2408                 if (trace)
2409                   {
2410                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2411                            "/** 0110 0001 1010 000              sub     %0, %e1                         */",
2412                            op[0], op[1]);
2413                   }
2414                 SYNTAX("sub     %0, %e1");
2415 #line 1127 "rl78-decode.opc"
2416                 ID(sub); DR(A); SM2(HL, B, 0); Fzac;
2417
2418               }
2419             break;
2420           case 0xa2:
2421               {
2422                 /** 0110 0001 1010 0010         sub     %0, %e1                         */
2423                 if (trace)
2424                   {
2425                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2426                            "/** 0110 0001 1010 0010             sub     %0, %e1                         */",
2427                            op[0], op[1]);
2428                   }
2429                 SYNTAX("sub     %0, %e1");
2430 #line 1133 "rl78-decode.opc"
2431                 ID(sub); DR(A); SM2(HL, C, 0); Fzac;
2432
2433               }
2434             break;
2435           case 0xa8:
2436               {
2437                 /** 0110 0001 1010 1000         xch     %0, %1                          */
2438                 if (trace)
2439                   {
2440                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2441                            "/** 0110 0001 1010 1000             xch     %0, %1                          */",
2442                            op[0], op[1]);
2443                   }
2444                 SYNTAX("xch     %0, %1");
2445 #line 1230 "rl78-decode.opc"
2446                 ID(xch); DR(A); SM(None, SADDR);
2447
2448               }
2449             break;
2450           case 0xa9:
2451               {
2452                 /** 0110 0001 1010 1001         xch     %0, %e1                         */
2453                 if (trace)
2454                   {
2455                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2456                            "/** 0110 0001 1010 1001             xch     %0, %e1                         */",
2457                            op[0], op[1]);
2458                   }
2459                 SYNTAX("xch     %0, %e1");
2460 #line 1223 "rl78-decode.opc"
2461                 ID(xch); DR(A); SM2(HL, C, 0);
2462
2463               }
2464             break;
2465           case 0xaa:
2466               {
2467                 /** 0110 0001 1010 1010         xch     %0, %e!1                        */
2468                 if (trace)
2469                   {
2470                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2471                            "/** 0110 0001 1010 1010             xch     %0, %e!1                        */",
2472                            op[0], op[1]);
2473                   }
2474                 SYNTAX("xch     %0, %e!1");
2475 #line 1205 "rl78-decode.opc"
2476                 ID(xch); DR(A); SM(None, IMMU(2));
2477
2478               }
2479             break;
2480           case 0xab:
2481               {
2482                 /** 0110 0001 1010 1011         xch     %0, %s1                         */
2483                 if (trace)
2484                   {
2485                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2486                            "/** 0110 0001 1010 1011             xch     %0, %s1                         */",
2487                            op[0], op[1]);
2488                   }
2489                 SYNTAX("xch     %0, %s1");
2490 #line 1233 "rl78-decode.opc"
2491                 ID(xch); DR(A); SM(None, SFR);
2492
2493               }
2494             break;
2495           case 0xac:
2496               {
2497                 /** 0110 0001 1010 1100         xch     %0, %e1                         */
2498                 if (trace)
2499                   {
2500                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2501                            "/** 0110 0001 1010 1100             xch     %0, %e1                         */",
2502                            op[0], op[1]);
2503                   }
2504                 SYNTAX("xch     %0, %e1");
2505 #line 1214 "rl78-decode.opc"
2506                 ID(xch); DR(A); SM(HL, 0);
2507
2508               }
2509             break;
2510           case 0xad:
2511               {
2512                 /** 0110 0001 1010 1101         xch     %0, %ea1                        */
2513                 if (trace)
2514                   {
2515                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2516                            "/** 0110 0001 1010 1101             xch     %0, %ea1                        */",
2517                            op[0], op[1]);
2518                   }
2519                 SYNTAX("xch     %0, %ea1");
2520 #line 1220 "rl78-decode.opc"
2521                 ID(xch); DR(A); SM(HL, IMMU(1));
2522
2523               }
2524             break;
2525           case 0xae:
2526               {
2527                 /** 0110 0001 1010 1110         xch     %0, %e1                         */
2528                 if (trace)
2529                   {
2530                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2531                            "/** 0110 0001 1010 1110             xch     %0, %e1                         */",
2532                            op[0], op[1]);
2533                   }
2534                 SYNTAX("xch     %0, %e1");
2535 #line 1208 "rl78-decode.opc"
2536                 ID(xch); DR(A); SM(DE, 0);
2537
2538               }
2539             break;
2540           case 0xaf:
2541               {
2542                 /** 0110 0001 1010 1111         xch     %0, %ea1                                */
2543                 if (trace)
2544                   {
2545                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2546                            "/** 0110 0001 1010 1111             xch     %0, %ea1                                */",
2547                            op[0], op[1]);
2548                   }
2549                 SYNTAX("xch     %0, %ea1");
2550 #line 1211 "rl78-decode.opc"
2551                 ID(xch); DR(A); SM(DE, IMMU(1));
2552
2553               }
2554             break;
2555           case 0xb0:
2556               {
2557                 /** 0110 0001 1011 0000         subc    %0, %e1                         */
2558                 if (trace)
2559                   {
2560                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2561                            "/** 0110 0001 1011 0000             subc    %0, %e1                         */",
2562                            op[0], op[1]);
2563                   }
2564                 SYNTAX("subc    %0, %e1");
2565 #line 1159 "rl78-decode.opc"
2566                 ID(subc); DR(A); SM2(HL, B, 0); Fzac;
2567
2568               }
2569             break;
2570           case 0xb2:
2571               {
2572                 /** 0110 0001 1011 0010         subc    %0, %e1                         */
2573                 if (trace)
2574                   {
2575                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2576                            "/** 0110 0001 1011 0010             subc    %0, %e1                         */",
2577                            op[0], op[1]);
2578                   }
2579                 SYNTAX("subc    %0, %e1");
2580 #line 1162 "rl78-decode.opc"
2581                 ID(subc); DR(A); SM2(HL, C, 0); Fzac;
2582
2583               }
2584             break;
2585           case 0xb8:
2586               {
2587                 /** 0110 0001 1011 1000         mov     %0, %1                          */
2588                 if (trace)
2589                   {
2590                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2591                            "/** 0110 0001 1011 1000             mov     %0, %1                          */",
2592                            op[0], op[1]);
2593                   }
2594                 SYNTAX("mov     %0, %1");
2595 #line 725 "rl78-decode.opc"
2596                 ID(mov); DR(ES); SM(None, SADDR);
2597
2598               }
2599             break;
2600           case 0xb9:
2601               {
2602                 /** 0110 0001 1011 1001         xch     %0, %e1                         */
2603                 if (trace)
2604                   {
2605                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2606                            "/** 0110 0001 1011 1001             xch     %0, %e1                         */",
2607                            op[0], op[1]);
2608                   }
2609                 SYNTAX("xch     %0, %e1");
2610 #line 1217 "rl78-decode.opc"
2611                 ID(xch); DR(A); SM2(HL, B, 0);
2612
2613               }
2614             break;
2615           case 0xc0:
2616               {
2617                 /** 0110 0001 1100 0000         cmp     %0, %e1                         */
2618                 if (trace)
2619                   {
2620                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2621                            "/** 0110 0001 1100 0000             cmp     %0, %e1                         */",
2622                            op[0], op[1]);
2623                   }
2624                 SYNTAX("cmp     %0, %e1");
2625 #line 494 "rl78-decode.opc"
2626                 ID(cmp); DR(A); SM2(HL, B, 0); Fzac;
2627
2628               }
2629             break;
2630           case 0xc2:
2631               {
2632                 /** 0110 0001 1100 0010         cmp     %0, %e1                         */
2633                 if (trace)
2634                   {
2635                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2636                            "/** 0110 0001 1100 0010             cmp     %0, %e1                         */",
2637                            op[0], op[1]);
2638                   }
2639                 SYNTAX("cmp     %0, %e1");
2640 #line 497 "rl78-decode.opc"
2641                 ID(cmp); DR(A); SM2(HL, C, 0); Fzac;
2642
2643               }
2644             break;
2645           case 0xc3:
2646               {
2647                 /** 0110 0001 1100 0011         bh      $%a0                            */
2648                 if (trace)
2649                   {
2650                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2651                            "/** 0110 0001 1100 0011             bh      $%a0                            */",
2652                            op[0], op[1]);
2653                   }
2654                 SYNTAX("bh      $%a0");
2655 #line 342 "rl78-decode.opc"
2656                 ID(branch_cond); DC(pc+IMMS(1)+3); SR(None); COND(H);
2657
2658               }
2659             break;
2660           case 0xc8:
2661               {
2662                 /** 0110 0001 1100 1000         sk%c1                                   */
2663                 if (trace)
2664                   {
2665                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2666                            "/** 0110 0001 1100 1000             sk%c1                                   */",
2667                            op[0], op[1]);
2668                   }
2669                 SYNTAX("sk%c1");
2670 #line 1096 "rl78-decode.opc"
2671                 ID(skip); COND(C);
2672
2673               }
2674             break;
2675           case 0xc9:
2676               {
2677                 /** 0110 0001 1100 1001         mov     %0, %e1                         */
2678                 if (trace)
2679                   {
2680                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2681                            "/** 0110 0001 1100 1001             mov     %0, %e1                         */",
2682                            op[0], op[1]);
2683                   }
2684                 SYNTAX("mov     %0, %e1");
2685 #line 662 "rl78-decode.opc"
2686                 ID(mov); DR(A); SM2(HL, B, 0);
2687
2688               }
2689             break;
2690           case 0xca:
2691           case 0xda:
2692           case 0xea:
2693           case 0xfa:
2694               {
2695                 /** 0110 0001 11rg 1010         call    %0                              */
2696 #line 432 "rl78-decode.opc"
2697                 int rg AU = (op[1] >> 4) & 0x03;
2698                 if (trace)
2699                   {
2700                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2701                            "/** 0110 0001 11rg 1010             call    %0                              */",
2702                            op[0], op[1]);
2703                     printf ("  rg = 0x%x\n", rg);
2704                   }
2705                 SYNTAX("call    %0");
2706 #line 432 "rl78-decode.opc"
2707                 ID(call); DRW(rg);
2708
2709               }
2710             break;
2711           case 0xcb:
2712               {
2713                 /** 0110 0001 1100 1011         br      ax                              */
2714                 if (trace)
2715                   {
2716                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2717                            "/** 0110 0001 1100 1011             br      ax                              */",
2718                            op[0], op[1]);
2719                   }
2720                 SYNTAX("br      ax");
2721 #line 382 "rl78-decode.opc"
2722                 ID(branch); DR(AX);
2723
2724               /*----------------------------------------------------------------------*/
2725
2726               }
2727             break;
2728           case 0xcc:
2729               {
2730                 /** 0110 0001 1100 1100         brk                                     */
2731                 if (trace)
2732                   {
2733                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2734                            "/** 0110 0001 1100 1100             brk                                     */",
2735                            op[0], op[1]);
2736                   }
2737                 SYNTAX("brk");
2738 #line 390 "rl78-decode.opc"
2739                 ID(break);
2740
2741               /*----------------------------------------------------------------------*/
2742
2743               }
2744             break;
2745           case 0xcd:
2746               {
2747                 /** 0110 0001 1100 1101         pop     %s0                             */
2748                 if (trace)
2749                   {
2750                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2751                            "/** 0110 0001 1100 1101             pop     %s0                             */",
2752                            op[0], op[1]);
2753                   }
2754                 SYNTAX("pop     %s0");
2755 #line 991 "rl78-decode.opc"
2756                 ID(mov); W(); DR(PSW); SPOP();
2757
2758               /*----------------------------------------------------------------------*/
2759
2760               }
2761             break;
2762           case 0xce:
2763               {
2764                 /** 0110 0001 1100 1110         movs    %ea0, %1                        */
2765                 if (trace)
2766                   {
2767                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2768                            "/** 0110 0001 1100 1110             movs    %ea0, %1                        */",
2769                            op[0], op[1]);
2770                   }
2771                 SYNTAX("movs    %ea0, %1");
2772 #line 813 "rl78-decode.opc"
2773                 ID(mov); DM(HL, IMMU(1)); SR(X); Fzc;
2774
2775               /*----------------------------------------------------------------------*/
2776
2777               }
2778             break;
2779           case 0xcf:
2780           case 0xdf:
2781           case 0xef:
2782           case 0xff:
2783               {
2784                 /** 0110 0001 11rb 1111         sel     rb%1                            */
2785 #line 1043 "rl78-decode.opc"
2786                 int rb AU = (op[1] >> 4) & 0x03;
2787                 if (trace)
2788                   {
2789                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2790                            "/** 0110 0001 11rb 1111             sel     rb%1                            */",
2791                            op[0], op[1]);
2792                     printf ("  rb = 0x%x\n", rb);
2793                   }
2794                 SYNTAX("sel     rb%1");
2795 #line 1043 "rl78-decode.opc"
2796                 ID(sel); SC(rb);
2797
2798               /*----------------------------------------------------------------------*/
2799
2800               }
2801             break;
2802           case 0xd0:
2803               {
2804                 /** 0110 0001 1101 0000         and     %0, %e1                 */
2805                 if (trace)
2806                   {
2807                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2808                            "/** 0110 0001 1101 0000             and     %0, %e1                 */",
2809                            op[0], op[1]);
2810                   }
2811                 SYNTAX("and     %0, %e1");
2812 #line 293 "rl78-decode.opc"
2813                 ID(and); DR(A); SM2(HL, B, 0); Fz;
2814
2815               }
2816             break;
2817           case 0xd2:
2818               {
2819                 /** 0110 0001 1101 0010         and     %0, %e1                 */
2820                 if (trace)
2821                   {
2822                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2823                            "/** 0110 0001 1101 0010             and     %0, %e1                 */",
2824                            op[0], op[1]);
2825                   }
2826                 SYNTAX("and     %0, %e1");
2827 #line 299 "rl78-decode.opc"
2828                 ID(and); DR(A); SM2(HL, C, 0); Fz;
2829
2830               }
2831             break;
2832           case 0xd3:
2833               {
2834                 /** 0110 0001 1101 0011         bnh     $%a0                            */
2835                 if (trace)
2836                   {
2837                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2838                            "/** 0110 0001 1101 0011             bnh     $%a0                            */",
2839                            op[0], op[1]);
2840                   }
2841                 SYNTAX("bnh     $%a0");
2842 #line 345 "rl78-decode.opc"
2843                 ID(branch_cond); DC(pc+IMMS(1)+3); SR(None); COND(NH);
2844
2845               }
2846             break;
2847           case 0xd8:
2848               {
2849                 /** 0110 0001 1101 1000         sk%c1                                   */
2850                 if (trace)
2851                   {
2852                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2853                            "/** 0110 0001 1101 1000             sk%c1                                   */",
2854                            op[0], op[1]);
2855                   }
2856                 SYNTAX("sk%c1");
2857 #line 1102 "rl78-decode.opc"
2858                 ID(skip); COND(NC);
2859
2860               }
2861             break;
2862           case 0xd9:
2863               {
2864                 /** 0110 0001 1101 1001         mov     %e0, %1                         */
2865                 if (trace)
2866                   {
2867                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2868                            "/** 0110 0001 1101 1001             mov     %e0, %1                         */",
2869                            op[0], op[1]);
2870                   }
2871                 SYNTAX("mov     %e0, %1");
2872 #line 629 "rl78-decode.opc"
2873                 ID(mov); DM2(HL, B, 0); SR(A);
2874
2875               }
2876             break;
2877           case 0xdb:
2878               {
2879                 /** 0110 0001 1101 1011         ror     %0, %1                          */
2880                 if (trace)
2881                   {
2882                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2883                            "/** 0110 0001 1101 1011             ror     %0, %1                          */",
2884                            op[0], op[1]);
2885                   }
2886                 SYNTAX("ror     %0, %1");
2887 #line 1024 "rl78-decode.opc"
2888                 ID(ror); DR(A); SC(1);
2889
2890               }
2891             break;
2892           case 0xdc:
2893               {
2894                 /** 0110 0001 1101 1100         rolc    %0, %1                          */
2895                 if (trace)
2896                   {
2897                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2898                            "/** 0110 0001 1101 1100             rolc    %0, %1                          */",
2899                            op[0], op[1]);
2900                   }
2901                 SYNTAX("rolc    %0, %1");
2902 #line 1018 "rl78-decode.opc"
2903                 ID(rolc); DR(A); SC(1);
2904
2905               }
2906             break;
2907           case 0xdd:
2908               {
2909                 /** 0110 0001 1101 1101         push    %s1                             */
2910                 if (trace)
2911                   {
2912                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2913                            "/** 0110 0001 1101 1101             push    %s1                             */",
2914                            op[0], op[1]);
2915                   }
2916                 SYNTAX("push    %s1");
2917 #line 999 "rl78-decode.opc"
2918                 ID(mov); W(); DPUSH(); SR(PSW);
2919
2920               /*----------------------------------------------------------------------*/
2921
2922               }
2923             break;
2924           case 0xde:
2925               {
2926                 /** 0110 0001 1101 1110         cmps    %0, %ea1                        */
2927                 if (trace)
2928                   {
2929                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2930                            "/** 0110 0001 1101 1110             cmps    %0, %ea1                        */",
2931                            op[0], op[1]);
2932                   }
2933                 SYNTAX("cmps    %0, %ea1");
2934 #line 528 "rl78-decode.opc"
2935                 ID(cmp); DR(X); SM(HL, IMMU(1)); Fzac;
2936
2937               /*----------------------------------------------------------------------*/
2938
2939               }
2940             break;
2941           case 0xe0:
2942               {
2943                 /** 0110 0001 1110 0000         or      %0, %e1                         */
2944                 if (trace)
2945                   {
2946                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2947                            "/** 0110 0001 1110 0000             or      %0, %e1                         */",
2948                            op[0], op[1]);
2949                   }
2950                 SYNTAX("or      %0, %e1");
2951 #line 948 "rl78-decode.opc"
2952                 ID(or); DR(A); SM2(HL, B, 0); Fz;
2953
2954               }
2955             break;
2956           case 0xe2:
2957               {
2958                 /** 0110 0001 1110 0010         or      %0, %e1                         */
2959                 if (trace)
2960                   {
2961                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2962                            "/** 0110 0001 1110 0010             or      %0, %e1                         */",
2963                            op[0], op[1]);
2964                   }
2965                 SYNTAX("or      %0, %e1");
2966 #line 954 "rl78-decode.opc"
2967                 ID(or); DR(A); SM2(HL, C, 0); Fz;
2968
2969               }
2970             break;
2971           case 0xe3:
2972               {
2973                 /** 0110 0001 1110 0011         sk%c1                                   */
2974                 if (trace)
2975                   {
2976                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2977                            "/** 0110 0001 1110 0011             sk%c1                                   */",
2978                            op[0], op[1]);
2979                   }
2980                 SYNTAX("sk%c1");
2981 #line 1099 "rl78-decode.opc"
2982                 ID(skip); COND(H);
2983
2984               }
2985             break;
2986           case 0xe8:
2987               {
2988                 /** 0110 0001 1110 1000         sk%c1                                   */
2989                 if (trace)
2990                   {
2991                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2992                            "/** 0110 0001 1110 1000             sk%c1                                   */",
2993                            op[0], op[1]);
2994                   }
2995                 SYNTAX("sk%c1");
2996 #line 1111 "rl78-decode.opc"
2997                 ID(skip); COND(Z);
2998
2999               /*----------------------------------------------------------------------*/
3000
3001               }
3002             break;
3003           case 0xe9:
3004               {
3005                 /** 0110 0001 1110 1001         mov     %0, %e1                         */
3006                 if (trace)
3007                   {
3008                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3009                            "/** 0110 0001 1110 1001             mov     %0, %e1                         */",
3010                            op[0], op[1]);
3011                   }
3012                 SYNTAX("mov     %0, %e1");
3013 #line 665 "rl78-decode.opc"
3014                 ID(mov); DR(A); SM2(HL, C, 0);
3015
3016               }
3017             break;
3018           case 0xeb:
3019               {
3020                 /** 0110 0001 1110 1011         rol     %0, %1                          */
3021                 if (trace)
3022                   {
3023                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3024                            "/** 0110 0001 1110 1011             rol     %0, %1                          */",
3025                            op[0], op[1]);
3026                   }
3027                 SYNTAX("rol     %0, %1");
3028 #line 1015 "rl78-decode.opc"
3029                 ID(rol); DR(A); SC(1);
3030
3031               }
3032             break;
3033           case 0xec:
3034               {
3035                 /** 0110 0001 1110 1100         retb                                    */
3036                 if (trace)
3037                   {
3038                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3039                            "/** 0110 0001 1110 1100             retb                                    */",
3040                            op[0], op[1]);
3041                   }
3042                 SYNTAX("retb");
3043 #line 1010 "rl78-decode.opc"
3044                 ID(reti);
3045
3046               /*----------------------------------------------------------------------*/
3047
3048               }
3049             break;
3050           case 0xed:
3051               {
3052                 /** 0110 0001 1110 1101         halt                                    */
3053                 if (trace)
3054                   {
3055                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3056                            "/** 0110 0001 1110 1101             halt                                    */",
3057                            op[0], op[1]);
3058                   }
3059                 SYNTAX("halt");
3060 #line 578 "rl78-decode.opc"
3061                 ID(halt);
3062
3063               /*----------------------------------------------------------------------*/
3064
3065               }
3066             break;
3067           case 0xee:
3068           case 0xfe:
3069               {
3070                 /** 0110 0001 111r 1110         rolwc   %0, %1                          */
3071 #line 1021 "rl78-decode.opc"
3072                 int r AU = (op[1] >> 4) & 0x01;
3073                 if (trace)
3074                   {
3075                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3076                            "/** 0110 0001 111r 1110             rolwc   %0, %1                          */",
3077                            op[0], op[1]);
3078                     printf ("  r = 0x%x\n", r);
3079                   }
3080                 SYNTAX("rolwc   %0, %1");
3081 #line 1021 "rl78-decode.opc"
3082                 ID(rolc); W(); DRW(r); SC(1);
3083
3084               }
3085             break;
3086           case 0xf0:
3087               {
3088                 /** 0110 0001 1111 0000         xor     %0, %e1                         */
3089                 if (trace)
3090                   {
3091                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3092                            "/** 0110 0001 1111 0000             xor     %0, %e1                         */",
3093                            op[0], op[1]);
3094                   }
3095                 SYNTAX("xor     %0, %e1");
3096 #line 1252 "rl78-decode.opc"
3097                 ID(xor); DR(A); SM2(HL, B, 0); Fz;
3098
3099               }
3100             break;
3101           case 0xf2:
3102               {
3103                 /** 0110 0001 1111 0010         xor     %0, %e1                         */
3104                 if (trace)
3105                   {
3106                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3107                            "/** 0110 0001 1111 0010             xor     %0, %e1                         */",
3108                            op[0], op[1]);
3109                   }
3110                 SYNTAX("xor     %0, %e1");
3111 #line 1258 "rl78-decode.opc"
3112                 ID(xor); DR(A); SM2(HL, C, 0); Fz;
3113
3114               }
3115             break;
3116           case 0xf3:
3117               {
3118                 /** 0110 0001 1111 0011         sk%c1                                   */
3119                 if (trace)
3120                   {
3121                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3122                            "/** 0110 0001 1111 0011             sk%c1                                   */",
3123                            op[0], op[1]);
3124                   }
3125                 SYNTAX("sk%c1");
3126 #line 1105 "rl78-decode.opc"
3127                 ID(skip); COND(NH);
3128
3129               }
3130             break;
3131           case 0xf8:
3132               {
3133                 /** 0110 0001 1111 1000         sk%c1                                   */
3134                 if (trace)
3135                   {
3136                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3137                            "/** 0110 0001 1111 1000             sk%c1                                   */",
3138                            op[0], op[1]);
3139                   }
3140                 SYNTAX("sk%c1");
3141 #line 1108 "rl78-decode.opc"
3142                 ID(skip); COND(NZ);
3143
3144               }
3145             break;
3146           case 0xf9:
3147               {
3148                 /** 0110 0001 1111 1001         mov     %e0, %1                         */
3149                 if (trace)
3150                   {
3151                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3152                            "/** 0110 0001 1111 1001             mov     %e0, %1                         */",
3153                            op[0], op[1]);
3154                   }
3155                 SYNTAX("mov     %e0, %1");
3156 #line 638 "rl78-decode.opc"
3157                 ID(mov); DM2(HL, C, 0); SR(A);
3158
3159               }
3160             break;
3161           case 0xfb:
3162               {
3163                 /** 0110 0001 1111 1011         rorc    %0, %1                          */
3164                 if (trace)
3165                   {
3166                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3167                            "/** 0110 0001 1111 1011             rorc    %0, %1                          */",
3168                            op[0], op[1]);
3169                   }
3170                 SYNTAX("rorc    %0, %1");
3171 #line 1027 "rl78-decode.opc"
3172                 ID(rorc); DR(A); SC(1);
3173
3174               /*----------------------------------------------------------------------*/
3175
3176               /* Note that the branch insns need to be listed before the shift
3177                  ones, as "shift count of zero" means "branch insn" */
3178
3179               }
3180             break;
3181           case 0xfc:
3182               {
3183                 /** 0110 0001 1111 1100         reti                                    */
3184                 if (trace)
3185                   {
3186                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3187                            "/** 0110 0001 1111 1100             reti                                    */",
3188                            op[0], op[1]);
3189                   }
3190                 SYNTAX("reti");
3191 #line 1007 "rl78-decode.opc"
3192                 ID(reti);
3193
3194               }
3195             break;
3196           case 0xfd:
3197               {
3198                 /** 0110 0001 1111 1101 stop                                            */
3199                 if (trace)
3200                   {
3201                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3202                            "/** 0110 0001 1111 1101     stop                                            */",
3203                            op[0], op[1]);
3204                   }
3205                 SYNTAX("stop");
3206 #line 1116 "rl78-decode.opc"
3207                 ID(stop);
3208
3209               /*----------------------------------------------------------------------*/
3210
3211               }
3212             break;
3213           default: UNSUPPORTED(); break;
3214         }
3215       break;
3216     case 0x68:
3217         {
3218           /** 0110 1000                 movw    %e0, %1                         */
3219           if (trace)
3220             {
3221               printf ("\033[33m%s\033[0m  %02x\n",
3222                      "/** 0110 1000                     movw    %e0, %1                         */",
3223                      op[0]);
3224             }
3225           SYNTAX("movw  %e0, %1");
3226 #line 876 "rl78-decode.opc"
3227           ID(mov); W(); DM(C, IMMU(2)); SR(AX);
3228
3229         }
3230       break;
3231     case 0x69:
3232         {
3233           /** 0110 1001                 movw    %0, %e1                         */
3234           if (trace)
3235             {
3236               printf ("\033[33m%s\033[0m  %02x\n",
3237                      "/** 0110 1001                     movw    %0, %e1                         */",
3238                      op[0]);
3239             }
3240           SYNTAX("movw  %0, %e1");
3241 #line 867 "rl78-decode.opc"
3242           ID(mov); W(); DR(AX); SM(C, IMMU(2));
3243
3244         }
3245       break;
3246     case 0x6a:
3247         {
3248           /** 0110 1010                 or      %0, #%1                         */
3249           if (trace)
3250             {
3251               printf ("\033[33m%s\033[0m  %02x\n",
3252                      "/** 0110 1010                     or      %0, #%1                         */",
3253                      op[0]);
3254             }
3255           SYNTAX("or    %0, #%1");
3256 #line 969 "rl78-decode.opc"
3257           ID(or); DM(None, SADDR); SC(IMMU(1)); Fz;
3258
3259         /*----------------------------------------------------------------------*/
3260
3261         }
3262       break;
3263     case 0x6b:
3264         {
3265           /** 0110 1011                 or      %0, %1                          */
3266           if (trace)
3267             {
3268               printf ("\033[33m%s\033[0m  %02x\n",
3269                      "/** 0110 1011                     or      %0, %1                          */",
3270                      op[0]);
3271             }
3272           SYNTAX("or    %0, %1");
3273 #line 966 "rl78-decode.opc"
3274           ID(or); DR(A); SM(None, SADDR); Fz;
3275
3276         }
3277       break;
3278     case 0x6c:
3279         {
3280           /** 0110 1100                 or      %0, #%1                         */
3281           if (trace)
3282             {
3283               printf ("\033[33m%s\033[0m  %02x\n",
3284                      "/** 0110 1100                     or      %0, #%1                         */",
3285                      op[0]);
3286             }
3287           SYNTAX("or    %0, #%1");
3288 #line 957 "rl78-decode.opc"
3289           ID(or); DR(A); SC(IMMU(1)); Fz;
3290
3291         }
3292       break;
3293     case 0x6d:
3294         {
3295           /** 0110 1101                 or      %0, %e1                         */
3296           if (trace)
3297             {
3298               printf ("\033[33m%s\033[0m  %02x\n",
3299                      "/** 0110 1101                     or      %0, %e1                         */",
3300                      op[0]);
3301             }
3302           SYNTAX("or    %0, %e1");
3303 #line 945 "rl78-decode.opc"
3304           ID(or); DR(A); SM(HL, 0); Fz;
3305
3306         }
3307       break;
3308     case 0x6e:
3309         {
3310           /** 0110 1110                 or      %0, %ea1                        */
3311           if (trace)
3312             {
3313               printf ("\033[33m%s\033[0m  %02x\n",
3314                      "/** 0110 1110                     or      %0, %ea1                        */",
3315                      op[0]);
3316             }
3317           SYNTAX("or    %0, %ea1");
3318 #line 951 "rl78-decode.opc"
3319           ID(or); DR(A); SM(HL, IMMU(1)); Fz;
3320
3321         }
3322       break;
3323     case 0x6f:
3324         {
3325           /** 0110 1111                 or      %0, %e!1                        */
3326           if (trace)
3327             {
3328               printf ("\033[33m%s\033[0m  %02x\n",
3329                      "/** 0110 1111                     or      %0, %e!1                        */",
3330                      op[0]);
3331             }
3332           SYNTAX("or    %0, %e!1");
3333 #line 942 "rl78-decode.opc"
3334           ID(or); DR(A); SM(None, IMMU(2)); Fz;
3335
3336         }
3337       break;
3338     case 0x70:
3339     case 0x72:
3340     case 0x73:
3341     case 0x74:
3342     case 0x75:
3343     case 0x76:
3344     case 0x77:
3345         {
3346           /** 0111 0rba                 mov     %0, %1                          */
3347 #line 698 "rl78-decode.opc"
3348           int rba AU = op[0] & 0x07;
3349           if (trace)
3350             {
3351               printf ("\033[33m%s\033[0m  %02x\n",
3352                      "/** 0111 0rba                     mov     %0, %1                          */",
3353                      op[0]);
3354               printf ("  rba = 0x%x\n", rba);
3355             }
3356           SYNTAX("mov   %0, %1");
3357 #line 698 "rl78-decode.opc"
3358           ID(mov); DRB(rba); SR(A);
3359
3360         }
3361       break;
3362     case 0x71:
3363         GETBYTE ();
3364         switch (op[1] & 0xff)
3365         {
3366           case 0x00:
3367           case 0x10:
3368           case 0x20:
3369           case 0x30:
3370           case 0x40:
3371           case 0x50:
3372           case 0x60:
3373           case 0x70:
3374               {
3375                 /** 0111 0001 0bit 0000         set1    %e!0                            */
3376 #line 1048 "rl78-decode.opc"
3377                 int bit AU = (op[1] >> 4) & 0x07;
3378                 if (trace)
3379                   {
3380                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3381                            "/** 0111 0001 0bit 0000             set1    %e!0                            */",
3382                            op[0], op[1]);
3383                     printf ("  bit = 0x%x\n", bit);
3384                   }
3385                 SYNTAX("set1    %e!0");
3386 #line 1048 "rl78-decode.opc"
3387                 ID(mov); DM(None, IMMU(2)); DB(bit); SC(1);
3388
3389               }
3390             break;
3391           case 0x01:
3392           case 0x11:
3393           case 0x21:
3394           case 0x31:
3395           case 0x41:
3396           case 0x51:
3397           case 0x61:
3398           case 0x71:
3399               {
3400                 /** 0111 0001 0bit 0001         mov1    %0, cy                          */
3401 #line 805 "rl78-decode.opc"
3402                 int bit AU = (op[1] >> 4) & 0x07;
3403                 if (trace)
3404                   {
3405                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3406                            "/** 0111 0001 0bit 0001             mov1    %0, cy                          */",
3407                            op[0], op[1]);
3408                     printf ("  bit = 0x%x\n", bit);
3409                   }
3410                 SYNTAX("mov1    %0, cy");
3411 #line 805 "rl78-decode.opc"
3412                 ID(mov); DM(None, SADDR); DB(bit); SCY();
3413
3414               }
3415             break;
3416           case 0x02:
3417           case 0x12:
3418           case 0x22:
3419           case 0x32:
3420           case 0x42:
3421           case 0x52:
3422           case 0x62:
3423           case 0x72:
3424               {
3425                 /** 0111 0001 0bit 0010         set1    %0                              */
3426 #line 1066 "rl78-decode.opc"
3427                 int bit AU = (op[1] >> 4) & 0x07;
3428                 if (trace)
3429                   {
3430                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3431                            "/** 0111 0001 0bit 0010             set1    %0                              */",
3432                            op[0], op[1]);
3433                     printf ("  bit = 0x%x\n", bit);
3434                   }
3435                 SYNTAX("set1    %0");
3436 #line 1066 "rl78-decode.opc"
3437                 ID(mov); DM(None, SADDR); DB(bit); SC(1);
3438
3439               /*----------------------------------------------------------------------*/
3440
3441               }
3442             break;
3443           case 0x03:
3444           case 0x13:
3445           case 0x23:
3446           case 0x33:
3447           case 0x43:
3448           case 0x53:
3449           case 0x63:
3450           case 0x73:
3451               {
3452                 /** 0111 0001 0bit 0011         clr1    %0                              */
3453 #line 458 "rl78-decode.opc"
3454                 int bit AU = (op[1] >> 4) & 0x07;
3455                 if (trace)
3456                   {
3457                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3458                            "/** 0111 0001 0bit 0011             clr1    %0                              */",
3459                            op[0], op[1]);
3460                     printf ("  bit = 0x%x\n", bit);
3461                   }
3462                 SYNTAX("clr1    %0");
3463 #line 458 "rl78-decode.opc"
3464                 ID(mov); DM(None, SADDR); DB(bit); SC(0);
3465
3466               /*----------------------------------------------------------------------*/
3467
3468               }
3469             break;
3470           case 0x04:
3471           case 0x14:
3472           case 0x24:
3473           case 0x34:
3474           case 0x44:
3475           case 0x54:
3476           case 0x64:
3477           case 0x74:
3478               {
3479                 /** 0111 0001 0bit 0100         mov1    cy, %1                          */
3480 #line 799 "rl78-decode.opc"
3481                 int bit AU = (op[1] >> 4) & 0x07;
3482                 if (trace)
3483                   {
3484                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3485                            "/** 0111 0001 0bit 0100             mov1    cy, %1                          */",
3486                            op[0], op[1]);
3487                     printf ("  bit = 0x%x\n", bit);
3488                   }
3489                 SYNTAX("mov1    cy, %1");
3490 #line 799 "rl78-decode.opc"
3491                 ID(mov); DCY(); SM(None, SADDR); SB(bit);
3492
3493               }
3494             break;
3495           case 0x05:
3496           case 0x15:
3497           case 0x25:
3498           case 0x35:
3499           case 0x45:
3500           case 0x55:
3501           case 0x65:
3502           case 0x75:
3503               {
3504                 /** 0111 0001 0bit 0101         and1    cy, %s1                         */
3505 #line 328 "rl78-decode.opc"
3506                 int bit AU = (op[1] >> 4) & 0x07;
3507                 if (trace)
3508                   {
3509                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3510                            "/** 0111 0001 0bit 0101             and1    cy, %s1                         */",
3511                            op[0], op[1]);
3512                     printf ("  bit = 0x%x\n", bit);
3513                   }
3514                 SYNTAX("and1    cy, %s1");
3515 #line 328 "rl78-decode.opc"
3516                 ID(and); DCY(); SM(None, SADDR); SB(bit);
3517
3518               /*----------------------------------------------------------------------*/
3519
3520               /* Note that the branch insns need to be listed before the shift
3521                  ones, as "shift count of zero" means "branch insn" */
3522
3523               }
3524             break;
3525           case 0x06:
3526           case 0x16:
3527           case 0x26:
3528           case 0x36:
3529           case 0x46:
3530           case 0x56:
3531           case 0x66:
3532           case 0x76:
3533               {
3534                 /** 0111 0001 0bit 0110         or1     cy, %s1                         */
3535 #line 983 "rl78-decode.opc"
3536                 int bit AU = (op[1] >> 4) & 0x07;
3537                 if (trace)
3538                   {
3539                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3540                            "/** 0111 0001 0bit 0110             or1     cy, %s1                         */",
3541                            op[0], op[1]);
3542                     printf ("  bit = 0x%x\n", bit);
3543                   }
3544                 SYNTAX("or1     cy, %s1");
3545 #line 983 "rl78-decode.opc"
3546                 ID(or); DCY(); SM(None, SADDR); SB(bit);
3547
3548               /*----------------------------------------------------------------------*/
3549
3550               }
3551             break;
3552           case 0x07:
3553           case 0x17:
3554           case 0x27:
3555           case 0x37:
3556           case 0x47:
3557           case 0x57:
3558           case 0x67:
3559           case 0x77:
3560               {
3561                 /** 0111 0001 0bit 0111         xor1    cy, %s1                         */
3562 #line 1287 "rl78-decode.opc"
3563                 int bit AU = (op[1] >> 4) & 0x07;
3564                 if (trace)
3565                   {
3566                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3567                            "/** 0111 0001 0bit 0111             xor1    cy, %s1                         */",
3568                            op[0], op[1]);
3569                     printf ("  bit = 0x%x\n", bit);
3570                   }
3571                 SYNTAX("xor1    cy, %s1");
3572 #line 1287 "rl78-decode.opc"
3573                 ID(xor); DCY(); SM(None, SADDR); SB(bit);
3574
3575               /*----------------------------------------------------------------------*/
3576
3577               }
3578             break;
3579           case 0x08:
3580           case 0x18:
3581           case 0x28:
3582           case 0x38:
3583           case 0x48:
3584           case 0x58:
3585           case 0x68:
3586           case 0x78:
3587               {
3588                 /** 0111 0001 0bit 1000         clr1    %e!0                            */
3589 #line 440 "rl78-decode.opc"
3590                 int bit AU = (op[1] >> 4) & 0x07;
3591                 if (trace)
3592                   {
3593                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3594                            "/** 0111 0001 0bit 1000             clr1    %e!0                            */",
3595                            op[0], op[1]);
3596                     printf ("  bit = 0x%x\n", bit);
3597                   }
3598                 SYNTAX("clr1    %e!0");
3599 #line 440 "rl78-decode.opc"
3600                 ID(mov); DM(None, IMMU(2)); DB(bit); SC(0);
3601
3602               }
3603             break;
3604           case 0x09:
3605           case 0x19:
3606           case 0x29:
3607           case 0x39:
3608           case 0x49:
3609           case 0x59:
3610           case 0x69:
3611           case 0x79:
3612               {
3613                 /** 0111 0001 0bit 1001         mov1    %s0, cy                         */
3614 #line 808 "rl78-decode.opc"
3615                 int bit AU = (op[1] >> 4) & 0x07;
3616                 if (trace)
3617                   {
3618                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3619                            "/** 0111 0001 0bit 1001             mov1    %s0, cy                         */",
3620                            op[0], op[1]);
3621                     printf ("  bit = 0x%x\n", bit);
3622                   }
3623                 SYNTAX("mov1    %s0, cy");
3624 #line 808 "rl78-decode.opc"
3625                 ID(mov); DM(None, SFR); DB(bit); SCY();
3626
3627               /*----------------------------------------------------------------------*/
3628
3629               }
3630             break;
3631           case 0x0a:
3632           case 0x1a:
3633           case 0x2a:
3634           case 0x3a:
3635           case 0x4a:
3636           case 0x5a:
3637           case 0x6a:
3638           case 0x7a:
3639               {
3640                 /** 0111 0001 0bit 1010         set1    %s0                             */
3641 #line 1060 "rl78-decode.opc"
3642                 int bit AU = (op[1] >> 4) & 0x07;
3643                 if (trace)
3644                   {
3645                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3646                            "/** 0111 0001 0bit 1010             set1    %s0                             */",
3647                            op[0], op[1]);
3648                     printf ("  bit = 0x%x\n", bit);
3649                   }
3650                 SYNTAX("set1    %s0");
3651 #line 1060 "rl78-decode.opc"
3652                 op0 = SFR;
3653                 ID(mov); DM(None, op0); DB(bit); SC(1);
3654                 if (op0 == RL78_SFR_PSW && bit == 7)
3655                   rl78->syntax = "ei";
3656
3657               }
3658             break;
3659           case 0x0b:
3660           case 0x1b:
3661           case 0x2b:
3662           case 0x3b:
3663           case 0x4b:
3664           case 0x5b:
3665           case 0x6b:
3666           case 0x7b:
3667               {
3668                 /** 0111 0001 0bit 1011         clr1    %s0                             */
3669 #line 452 "rl78-decode.opc"
3670                 int bit AU = (op[1] >> 4) & 0x07;
3671                 if (trace)
3672                   {
3673                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3674                            "/** 0111 0001 0bit 1011             clr1    %s0                             */",
3675                            op[0], op[1]);
3676                     printf ("  bit = 0x%x\n", bit);
3677                   }
3678                 SYNTAX("clr1    %s0");
3679 #line 452 "rl78-decode.opc"
3680                 op0 = SFR;
3681                 ID(mov); DM(None, op0); DB(bit); SC(0);
3682                 if (op0 == RL78_SFR_PSW && bit == 7)
3683                   rl78->syntax = "di";
3684
3685               }
3686             break;
3687           case 0x0c:
3688           case 0x1c:
3689           case 0x2c:
3690           case 0x3c:
3691           case 0x4c:
3692           case 0x5c:
3693           case 0x6c:
3694           case 0x7c:
3695               {
3696                 /** 0111 0001 0bit 1100         mov1    cy, %s1                         */
3697 #line 802 "rl78-decode.opc"
3698                 int bit AU = (op[1] >> 4) & 0x07;
3699                 if (trace)
3700                   {
3701                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3702                            "/** 0111 0001 0bit 1100             mov1    cy, %s1                         */",
3703                            op[0], op[1]);
3704                     printf ("  bit = 0x%x\n", bit);
3705                   }
3706                 SYNTAX("mov1    cy, %s1");
3707 #line 802 "rl78-decode.opc"
3708                 ID(mov); DCY(); SM(None, SFR); SB(bit);
3709
3710               }
3711             break;
3712           case 0x0d:
3713           case 0x1d:
3714           case 0x2d:
3715           case 0x3d:
3716           case 0x4d:
3717           case 0x5d:
3718           case 0x6d:
3719           case 0x7d:
3720               {
3721                 /** 0111 0001 0bit 1101         and1    cy, %s1                         */
3722 #line 325 "rl78-decode.opc"
3723                 int bit AU = (op[1] >> 4) & 0x07;
3724                 if (trace)
3725                   {
3726                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3727                            "/** 0111 0001 0bit 1101             and1    cy, %s1                         */",
3728                            op[0], op[1]);
3729                     printf ("  bit = 0x%x\n", bit);
3730                   }
3731                 SYNTAX("and1    cy, %s1");
3732 #line 325 "rl78-decode.opc"
3733                 ID(and); DCY(); SM(None, SFR); SB(bit);
3734
3735               }
3736             break;
3737           case 0x0e:
3738           case 0x1e:
3739           case 0x2e:
3740           case 0x3e:
3741           case 0x4e:
3742           case 0x5e:
3743           case 0x6e:
3744           case 0x7e:
3745               {
3746                 /** 0111 0001 0bit 1110         or1     cy, %s1                         */
3747 #line 980 "rl78-decode.opc"
3748                 int bit AU = (op[1] >> 4) & 0x07;
3749                 if (trace)
3750                   {
3751                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3752                            "/** 0111 0001 0bit 1110             or1     cy, %s1                         */",
3753                            op[0], op[1]);
3754                     printf ("  bit = 0x%x\n", bit);
3755                   }
3756                 SYNTAX("or1     cy, %s1");
3757 #line 980 "rl78-decode.opc"
3758                 ID(or); DCY(); SM(None, SFR); SB(bit);
3759
3760               }
3761             break;
3762           case 0x0f:
3763           case 0x1f:
3764           case 0x2f:
3765           case 0x3f:
3766           case 0x4f:
3767           case 0x5f:
3768           case 0x6f:
3769           case 0x7f:
3770               {
3771                 /** 0111 0001 0bit 1111         xor1    cy, %s1                         */
3772 #line 1284 "rl78-decode.opc"
3773                 int bit AU = (op[1] >> 4) & 0x07;
3774                 if (trace)
3775                   {
3776                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3777                            "/** 0111 0001 0bit 1111             xor1    cy, %s1                         */",
3778                            op[0], op[1]);
3779                     printf ("  bit = 0x%x\n", bit);
3780                   }
3781                 SYNTAX("xor1    cy, %s1");
3782 #line 1284 "rl78-decode.opc"
3783                 ID(xor); DCY(); SM(None, SFR); SB(bit);
3784
3785               }
3786             break;
3787           case 0x80:
3788               {
3789                 /** 0111 0001 1000 0000         set1    cy                              */
3790                 if (trace)
3791                   {
3792                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3793                            "/** 0111 0001 1000 0000             set1    cy                              */",
3794                            op[0], op[1]);
3795                   }
3796                 SYNTAX("set1    cy");
3797 #line 1057 "rl78-decode.opc"
3798                 ID(mov); DCY(); SC(1);
3799
3800               }
3801             break;
3802           case 0x81:
3803           case 0x91:
3804           case 0xa1:
3805           case 0xb1:
3806           case 0xc1:
3807           case 0xd1:
3808           case 0xe1:
3809           case 0xf1:
3810               {
3811                 /** 0111 0001 1bit 0001         mov1    %e0, cy                         */
3812 #line 787 "rl78-decode.opc"
3813                 int bit AU = (op[1] >> 4) & 0x07;
3814                 if (trace)
3815                   {
3816                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3817                            "/** 0111 0001 1bit 0001             mov1    %e0, cy                         */",
3818                            op[0], op[1]);
3819                     printf ("  bit = 0x%x\n", bit);
3820                   }
3821                 SYNTAX("mov1    %e0, cy");
3822 #line 787 "rl78-decode.opc"
3823                 ID(mov); DM(HL, 0); DB(bit); SCY();
3824
3825               }
3826             break;
3827           case 0x82:
3828           case 0x92:
3829           case 0xa2:
3830           case 0xb2:
3831           case 0xc2:
3832           case 0xd2:
3833           case 0xe2:
3834           case 0xf2:
3835               {
3836                 /** 0111 0001 1bit 0010         set1    %e0                             */
3837 #line 1051 "rl78-decode.opc"
3838                 int bit AU = (op[1] >> 4) & 0x07;
3839                 if (trace)
3840                   {
3841                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3842                            "/** 0111 0001 1bit 0010             set1    %e0                             */",
3843                            op[0], op[1]);
3844                     printf ("  bit = 0x%x\n", bit);
3845                   }
3846                 SYNTAX("set1    %e0");
3847 #line 1051 "rl78-decode.opc"
3848                 ID(mov); DM(HL, 0); DB(bit); SC(1);
3849
3850               }
3851             break;
3852           case 0x83:
3853           case 0x93:
3854           case 0xa3:
3855           case 0xb3:
3856           case 0xc3:
3857           case 0xd3:
3858           case 0xe3:
3859           case 0xf3:
3860               {
3861                 /** 0111 0001 1bit 0011         clr1    %e0                             */
3862 #line 443 "rl78-decode.opc"
3863                 int bit AU = (op[1] >> 4) & 0x07;
3864                 if (trace)
3865                   {
3866                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3867                            "/** 0111 0001 1bit 0011             clr1    %e0                             */",
3868                            op[0], op[1]);
3869                     printf ("  bit = 0x%x\n", bit);
3870                   }
3871                 SYNTAX("clr1    %e0");
3872 #line 443 "rl78-decode.opc"
3873                 ID(mov); DM(HL, 0); DB(bit); SC(0);
3874
3875               }
3876             break;
3877           case 0x84:
3878           case 0x94:
3879           case 0xa4:
3880           case 0xb4:
3881           case 0xc4:
3882           case 0xd4:
3883           case 0xe4:
3884           case 0xf4:
3885               {
3886                 /** 0111 0001 1bit 0100         mov1    cy, %e1                         */
3887 #line 793 "rl78-decode.opc"
3888                 int bit AU = (op[1] >> 4) & 0x07;
3889                 if (trace)
3890                   {
3891                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3892                            "/** 0111 0001 1bit 0100             mov1    cy, %e1                         */",
3893                            op[0], op[1]);
3894                     printf ("  bit = 0x%x\n", bit);
3895                   }
3896                 SYNTAX("mov1    cy, %e1");
3897 #line 793 "rl78-decode.opc"
3898                 ID(mov); DCY(); SM(HL, 0); SB(bit);
3899
3900               }
3901             break;
3902           case 0x85:
3903           case 0x95:
3904           case 0xa5:
3905           case 0xb5:
3906           case 0xc5:
3907           case 0xd5:
3908           case 0xe5:
3909           case 0xf5:
3910               {
3911                 /** 0111 0001 1bit 0101         and1    cy, %e1                 */
3912 #line 319 "rl78-decode.opc"
3913                 int bit AU = (op[1] >> 4) & 0x07;
3914                 if (trace)
3915                   {
3916                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3917                            "/** 0111 0001 1bit 0101             and1    cy, %e1                 */",
3918                            op[0], op[1]);
3919                     printf ("  bit = 0x%x\n", bit);
3920                   }
3921                 SYNTAX("and1    cy, %e1");
3922 #line 319 "rl78-decode.opc"
3923                 ID(and); DCY(); SM(HL, 0); SB(bit);
3924
3925               }
3926             break;
3927           case 0x86:
3928           case 0x96:
3929           case 0xa6:
3930           case 0xb6:
3931           case 0xc6:
3932           case 0xd6:
3933           case 0xe6:
3934           case 0xf6:
3935               {
3936                 /** 0111 0001 1bit 0110         or1     cy, %e1                         */
3937 #line 974 "rl78-decode.opc"
3938                 int bit AU = (op[1] >> 4) & 0x07;
3939                 if (trace)
3940                   {
3941                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3942                            "/** 0111 0001 1bit 0110             or1     cy, %e1                         */",
3943                            op[0], op[1]);
3944                     printf ("  bit = 0x%x\n", bit);
3945                   }
3946                 SYNTAX("or1     cy, %e1");
3947 #line 974 "rl78-decode.opc"
3948                 ID(or); DCY(); SM(HL, 0); SB(bit);
3949
3950               }
3951             break;
3952           case 0x87:
3953           case 0x97:
3954           case 0xa7:
3955           case 0xb7:
3956           case 0xc7:
3957           case 0xd7:
3958           case 0xe7:
3959           case 0xf7:
3960               {
3961                 /** 0111 0001 1bit 0111         xor1    cy, %e1                         */
3962 #line 1278 "rl78-decode.opc"
3963                 int bit AU = (op[1] >> 4) & 0x07;
3964                 if (trace)
3965                   {
3966                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3967                            "/** 0111 0001 1bit 0111             xor1    cy, %e1                         */",
3968                            op[0], op[1]);
3969                     printf ("  bit = 0x%x\n", bit);
3970                   }
3971                 SYNTAX("xor1    cy, %e1");
3972 #line 1278 "rl78-decode.opc"
3973                 ID(xor); DCY(); SM(HL, 0); SB(bit);
3974
3975               }
3976             break;
3977           case 0x88:
3978               {
3979                 /** 0111 0001 1000 1000         clr1    cy                              */
3980                 if (trace)
3981                   {
3982                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3983                            "/** 0111 0001 1000 1000             clr1    cy                              */",
3984                            op[0], op[1]);
3985                   }
3986                 SYNTAX("clr1    cy");
3987 #line 449 "rl78-decode.opc"
3988                 ID(mov); DCY(); SC(0);
3989
3990               }
3991             break;
3992           case 0x89:
3993           case 0x99:
3994           case 0xa9:
3995           case 0xb9:
3996           case 0xc9:
3997           case 0xd9:
3998           case 0xe9:
3999           case 0xf9:
4000               {
4001                 /** 0111 0001 1bit 1001         mov1    %e0, cy                         */
4002 #line 790 "rl78-decode.opc"
4003                 int bit AU = (op[1] >> 4) & 0x07;
4004                 if (trace)
4005                   {
4006                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4007                            "/** 0111 0001 1bit 1001             mov1    %e0, cy                         */",
4008                            op[0], op[1]);
4009                     printf ("  bit = 0x%x\n", bit);
4010                   }
4011                 SYNTAX("mov1    %e0, cy");
4012 #line 790 "rl78-decode.opc"
4013                 ID(mov); DR(A); DB(bit); SCY();
4014
4015               }
4016             break;
4017           case 0x8a:
4018           case 0x9a:
4019           case 0xaa:
4020           case 0xba:
4021           case 0xca:
4022           case 0xda:
4023           case 0xea:
4024           case 0xfa:
4025               {
4026                 /** 0111 0001 1bit 1010         set1    %0                              */
4027 #line 1054 "rl78-decode.opc"
4028                 int bit AU = (op[1] >> 4) & 0x07;
4029                 if (trace)
4030                   {
4031                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4032                            "/** 0111 0001 1bit 1010             set1    %0                              */",
4033                            op[0], op[1]);
4034                     printf ("  bit = 0x%x\n", bit);
4035                   }
4036                 SYNTAX("set1    %0");
4037 #line 1054 "rl78-decode.opc"
4038                 ID(mov); DR(A); DB(bit); SC(1);
4039
4040               }
4041             break;
4042           case 0x8b:
4043           case 0x9b:
4044           case 0xab:
4045           case 0xbb:
4046           case 0xcb:
4047           case 0xdb:
4048           case 0xeb:
4049           case 0xfb:
4050               {
4051                 /** 0111 0001 1bit 1011         clr1    %0                              */
4052 #line 446 "rl78-decode.opc"
4053                 int bit AU = (op[1] >> 4) & 0x07;
4054                 if (trace)
4055                   {
4056                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4057                            "/** 0111 0001 1bit 1011             clr1    %0                              */",
4058                            op[0], op[1]);
4059                     printf ("  bit = 0x%x\n", bit);
4060                   }
4061                 SYNTAX("clr1    %0");
4062 #line 446 "rl78-decode.opc"
4063                 ID(mov); DR(A); DB(bit); SC(0);
4064
4065               }
4066             break;
4067           case 0x8c:
4068           case 0x9c:
4069           case 0xac:
4070           case 0xbc:
4071           case 0xcc:
4072           case 0xdc:
4073           case 0xec:
4074           case 0xfc:
4075               {
4076                 /** 0111 0001 1bit 1100         mov1    cy, %e1                         */
4077 #line 796 "rl78-decode.opc"
4078                 int bit AU = (op[1] >> 4) & 0x07;
4079                 if (trace)
4080                   {
4081                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4082                            "/** 0111 0001 1bit 1100             mov1    cy, %e1                         */",
4083                            op[0], op[1]);
4084                     printf ("  bit = 0x%x\n", bit);
4085                   }
4086                 SYNTAX("mov1    cy, %e1");
4087 #line 796 "rl78-decode.opc"
4088                 ID(mov); DCY(); SR(A); SB(bit);
4089
4090               }
4091             break;
4092           case 0x8d:
4093           case 0x9d:
4094           case 0xad:
4095           case 0xbd:
4096           case 0xcd:
4097           case 0xdd:
4098           case 0xed:
4099           case 0xfd:
4100               {
4101                 /** 0111 0001 1bit 1101         and1    cy, %1                          */
4102 #line 322 "rl78-decode.opc"
4103                 int bit AU = (op[1] >> 4) & 0x07;
4104                 if (trace)
4105                   {
4106                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4107                            "/** 0111 0001 1bit 1101             and1    cy, %1                          */",
4108                            op[0], op[1]);
4109                     printf ("  bit = 0x%x\n", bit);
4110                   }
4111                 SYNTAX("and1    cy, %1");
4112 #line 322 "rl78-decode.opc"
4113                 ID(and); DCY(); SR(A); SB(bit);
4114
4115               }
4116             break;
4117           case 0x8e:
4118           case 0x9e:
4119           case 0xae:
4120           case 0xbe:
4121           case 0xce:
4122           case 0xde:
4123           case 0xee:
4124           case 0xfe:
4125               {
4126                 /** 0111 0001 1bit 1110         or1     cy, %1                          */
4127 #line 977 "rl78-decode.opc"
4128                 int bit AU = (op[1] >> 4) & 0x07;
4129                 if (trace)
4130                   {
4131                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4132                            "/** 0111 0001 1bit 1110             or1     cy, %1                          */",
4133                            op[0], op[1]);
4134                     printf ("  bit = 0x%x\n", bit);
4135                   }
4136                 SYNTAX("or1     cy, %1");
4137 #line 977 "rl78-decode.opc"
4138                 ID(or); DCY(); SR(A); SB(bit);
4139
4140               }
4141             break;
4142           case 0x8f:
4143           case 0x9f:
4144           case 0xaf:
4145           case 0xbf:
4146           case 0xcf:
4147           case 0xdf:
4148           case 0xef:
4149           case 0xff:
4150               {
4151                 /** 0111 0001 1bit 1111         xor1    cy, %1                          */
4152 #line 1281 "rl78-decode.opc"
4153                 int bit AU = (op[1] >> 4) & 0x07;
4154                 if (trace)
4155                   {
4156                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4157                            "/** 0111 0001 1bit 1111             xor1    cy, %1                          */",
4158                            op[0], op[1]);
4159                     printf ("  bit = 0x%x\n", bit);
4160                   }
4161                 SYNTAX("xor1    cy, %1");
4162 #line 1281 "rl78-decode.opc"
4163                 ID(xor); DCY(); SR(A); SB(bit);
4164
4165               }
4166             break;
4167           case 0xc0:
4168               {
4169                 /** 0111 0001 1100 0000         not1    cy                              */
4170                 if (trace)
4171                   {
4172                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4173                            "/** 0111 0001 1100 0000             not1    cy                              */",
4174                            op[0], op[1]);
4175                   }
4176                 SYNTAX("not1    cy");
4177 #line 918 "rl78-decode.opc"
4178                 ID(xor); DCY(); SC(1);
4179
4180               /*----------------------------------------------------------------------*/
4181
4182               }
4183             break;
4184           default: UNSUPPORTED(); break;
4185         }
4186       break;
4187     case 0x78:
4188         {
4189           /** 0111 1000                 movw    %e0, %1                         */
4190           if (trace)
4191             {
4192               printf ("\033[33m%s\033[0m  %02x\n",
4193                      "/** 0111 1000                     movw    %e0, %1                         */",
4194                      op[0]);
4195             }
4196           SYNTAX("movw  %e0, %1");
4197 #line 879 "rl78-decode.opc"
4198           ID(mov); W(); DM(BC, IMMU(2)); SR(AX);
4199
4200         }
4201       break;
4202     case 0x79:
4203         {
4204           /** 0111 1001                 movw    %0, %e1                         */
4205           if (trace)
4206             {
4207               printf ("\033[33m%s\033[0m  %02x\n",
4208                      "/** 0111 1001                     movw    %0, %e1                         */",
4209                      op[0]);
4210             }
4211           SYNTAX("movw  %0, %e1");
4212 #line 870 "rl78-decode.opc"
4213           ID(mov); W(); DR(AX); SM(BC, IMMU(2));
4214
4215         }
4216       break;
4217     case 0x7a:
4218         {
4219           /** 0111 1010                 xor     %0, #%1                         */
4220           if (trace)
4221             {
4222               printf ("\033[33m%s\033[0m  %02x\n",
4223                      "/** 0111 1010                     xor     %0, #%1                         */",
4224                      op[0]);
4225             }
4226           SYNTAX("xor   %0, #%1");
4227 #line 1273 "rl78-decode.opc"
4228           ID(xor); DM(None, SADDR); SC(IMMU(1)); Fz;
4229
4230         /*----------------------------------------------------------------------*/
4231
4232         }
4233       break;
4234     case 0x7b:
4235         {
4236           /** 0111 1011                 xor     %0, %1                          */
4237           if (trace)
4238             {
4239               printf ("\033[33m%s\033[0m  %02x\n",
4240                      "/** 0111 1011                     xor     %0, %1                          */",
4241                      op[0]);
4242             }
4243           SYNTAX("xor   %0, %1");
4244 #line 1270 "rl78-decode.opc"
4245           ID(xor); DR(A); SM(None, SADDR); Fz;
4246
4247         }
4248       break;
4249     case 0x7c:
4250         {
4251           /** 0111 1100                 xor     %0, #%1                         */
4252           if (trace)
4253             {
4254               printf ("\033[33m%s\033[0m  %02x\n",
4255                      "/** 0111 1100                     xor     %0, #%1                         */",
4256                      op[0]);
4257             }
4258           SYNTAX("xor   %0, #%1");
4259 #line 1261 "rl78-decode.opc"
4260           ID(xor); DR(A); SC(IMMU(1)); Fz;
4261
4262         }
4263       break;
4264     case 0x7d:
4265         {
4266           /** 0111 1101                 xor     %0, %e1                         */
4267           if (trace)
4268             {
4269               printf ("\033[33m%s\033[0m  %02x\n",
4270                      "/** 0111 1101                     xor     %0, %e1                         */",
4271                      op[0]);
4272             }
4273           SYNTAX("xor   %0, %e1");
4274 #line 1249 "rl78-decode.opc"
4275           ID(xor); DR(A); SM(HL, 0); Fz;
4276
4277         }
4278       break;
4279     case 0x7e:
4280         {
4281           /** 0111 1110                 xor     %0, %ea1                        */
4282           if (trace)
4283             {
4284               printf ("\033[33m%s\033[0m  %02x\n",
4285                      "/** 0111 1110                     xor     %0, %ea1                        */",
4286                      op[0]);
4287             }
4288           SYNTAX("xor   %0, %ea1");
4289 #line 1255 "rl78-decode.opc"
4290           ID(xor); DR(A); SM(HL, IMMU(1)); Fz;
4291
4292         }
4293       break;
4294     case 0x7f:
4295         {
4296           /** 0111 1111                 xor     %0, %e!1                        */
4297           if (trace)
4298             {
4299               printf ("\033[33m%s\033[0m  %02x\n",
4300                      "/** 0111 1111                     xor     %0, %e!1                        */",
4301                      op[0]);
4302             }
4303           SYNTAX("xor   %0, %e!1");
4304 #line 1246 "rl78-decode.opc"
4305           ID(xor); DR(A); SM(None, IMMU(2)); Fz;
4306
4307         }
4308       break;
4309     case 0x80:
4310     case 0x81:
4311     case 0x82:
4312     case 0x83:
4313     case 0x84:
4314     case 0x85:
4315     case 0x86:
4316     case 0x87:
4317         {
4318           /** 1000 0reg                 inc     %0                              */
4319 #line 589 "rl78-decode.opc"
4320           int reg AU = op[0] & 0x07;
4321           if (trace)
4322             {
4323               printf ("\033[33m%s\033[0m  %02x\n",
4324                      "/** 1000 0reg                     inc     %0                              */",
4325                      op[0]);
4326               printf ("  reg = 0x%x\n", reg);
4327             }
4328           SYNTAX("inc   %0");
4329 #line 589 "rl78-decode.opc"
4330           ID(add); DRB(reg); SC(1); Fza;
4331
4332         }
4333       break;
4334     case 0x88:
4335         {
4336           /** 1000 1000                 mov     %0, %ea1                        */
4337           if (trace)
4338             {
4339               printf ("\033[33m%s\033[0m  %02x\n",
4340                      "/** 1000 1000                     mov     %0, %ea1                        */",
4341                      op[0]);
4342             }
4343           SYNTAX("mov   %0, %ea1");
4344 #line 668 "rl78-decode.opc"
4345           ID(mov); DR(A); SM(SP, IMMU(1));
4346
4347         }
4348       break;
4349     case 0x89:
4350         {
4351           /** 1000 1001                 mov     %0, %e1                         */
4352           if (trace)
4353             {
4354               printf ("\033[33m%s\033[0m  %02x\n",
4355                      "/** 1000 1001                     mov     %0, %e1                         */",
4356                      op[0]);
4357             }
4358           SYNTAX("mov   %0, %e1");
4359 #line 650 "rl78-decode.opc"
4360           ID(mov); DR(A); SM(DE, 0);
4361
4362         }
4363       break;
4364     case 0x8a:
4365         {
4366           /** 1000 1010                 mov     %0, %ea1                        */
4367           if (trace)
4368             {
4369               printf ("\033[33m%s\033[0m  %02x\n",
4370                      "/** 1000 1010                     mov     %0, %ea1                        */",
4371                      op[0]);
4372             }
4373           SYNTAX("mov   %0, %ea1");
4374 #line 653 "rl78-decode.opc"
4375           ID(mov); DR(A); SM(DE, IMMU(1));
4376
4377         }
4378       break;
4379     case 0x8b:
4380         {
4381           /** 1000 1011                 mov     %0, %e1                         */
4382           if (trace)
4383             {
4384               printf ("\033[33m%s\033[0m  %02x\n",
4385                      "/** 1000 1011                     mov     %0, %e1                         */",
4386                      op[0]);
4387             }
4388           SYNTAX("mov   %0, %e1");
4389 #line 656 "rl78-decode.opc"
4390           ID(mov); DR(A); SM(HL, 0);
4391
4392         }
4393       break;
4394     case 0x8c:
4395         {
4396           /** 1000 1100                 mov     %0, %ea1                        */
4397           if (trace)
4398             {
4399               printf ("\033[33m%s\033[0m  %02x\n",
4400                      "/** 1000 1100                     mov     %0, %ea1                        */",
4401                      op[0]);
4402             }
4403           SYNTAX("mov   %0, %ea1");
4404 #line 659 "rl78-decode.opc"
4405           ID(mov); DR(A); SM(HL, IMMU(1));
4406
4407         }
4408       break;
4409     case 0x8d:
4410         {
4411           /** 1000 1101                 mov     %0, %1                          */
4412           if (trace)
4413             {
4414               printf ("\033[33m%s\033[0m  %02x\n",
4415                      "/** 1000 1101                     mov     %0, %1                          */",
4416                      op[0]);
4417             }
4418           SYNTAX("mov   %0, %1");
4419 #line 692 "rl78-decode.opc"
4420           ID(mov); DR(A); SM(None, SADDR);
4421
4422         }
4423       break;
4424     case 0x8e:
4425         {
4426           /** 1000 1110                 mov     %0, %s1                         */
4427           if (trace)
4428             {
4429               printf ("\033[33m%s\033[0m  %02x\n",
4430                      "/** 1000 1110                     mov     %0, %s1                         */",
4431                      op[0]);
4432             }
4433           SYNTAX("mov   %0, %s1");
4434 #line 689 "rl78-decode.opc"
4435           ID(mov); DR(A); SM(None, SFR);
4436
4437         }
4438       break;
4439     case 0x8f:
4440         {
4441           /** 1000 1111                 mov     %0, %e!1                        */
4442           if (trace)
4443             {
4444               printf ("\033[33m%s\033[0m  %02x\n",
4445                      "/** 1000 1111                     mov     %0, %e!1                        */",
4446                      op[0]);
4447             }
4448           SYNTAX("mov   %0, %e!1");
4449 #line 647 "rl78-decode.opc"
4450           ID(mov); DR(A); SM(None, IMMU(2));
4451
4452         }
4453       break;
4454     case 0x90:
4455     case 0x91:
4456     case 0x92:
4457     case 0x93:
4458     case 0x94:
4459     case 0x95:
4460     case 0x96:
4461     case 0x97:
4462         {
4463           /** 1001 0reg                 dec     %0                              */
4464 #line 556 "rl78-decode.opc"
4465           int reg AU = op[0] & 0x07;
4466           if (trace)
4467             {
4468               printf ("\033[33m%s\033[0m  %02x\n",
4469                      "/** 1001 0reg                     dec     %0                              */",
4470                      op[0]);
4471               printf ("  reg = 0x%x\n", reg);
4472             }
4473           SYNTAX("dec   %0");
4474 #line 556 "rl78-decode.opc"
4475           ID(sub); DRB(reg); SC(1); Fza;
4476
4477         }
4478       break;
4479     case 0x98:
4480         {
4481           /** 1001 1000                 mov     %a0, %1                         */
4482           if (trace)
4483             {
4484               printf ("\033[33m%s\033[0m  %02x\n",
4485                      "/** 1001 1000                     mov     %a0, %1                         */",
4486                      op[0]);
4487             }
4488           SYNTAX("mov   %a0, %1");
4489 #line 644 "rl78-decode.opc"
4490           ID(mov); DM(SP, IMMU(1)); SR(A);
4491
4492         }
4493       break;
4494     case 0x99:
4495         {
4496           /** 1001 1001                 mov     %e0, %1                         */
4497           if (trace)
4498             {
4499               printf ("\033[33m%s\033[0m  %02x\n",
4500                      "/** 1001 1001                     mov     %e0, %1                         */",
4501                      op[0]);
4502             }
4503           SYNTAX("mov   %e0, %1");
4504 #line 617 "rl78-decode.opc"
4505           ID(mov); DM(DE, 0); SR(A);
4506
4507         }
4508       break;
4509     case 0x9a:
4510         {
4511           /** 1001 1010                 mov     %ea0, %1                                */
4512           if (trace)
4513             {
4514               printf ("\033[33m%s\033[0m  %02x\n",
4515                      "/** 1001 1010                     mov     %ea0, %1                                */",
4516                      op[0]);
4517             }
4518           SYNTAX("mov   %ea0, %1");
4519 #line 623 "rl78-decode.opc"
4520           ID(mov); DM(DE, IMMU(1)); SR(A);
4521
4522         }
4523       break;
4524     case 0x9b:
4525         {
4526           /** 1001 1011                 mov     %e0, %1                         */
4527           if (trace)
4528             {
4529               printf ("\033[33m%s\033[0m  %02x\n",
4530                      "/** 1001 1011                     mov     %e0, %1                         */",
4531                      op[0]);
4532             }
4533           SYNTAX("mov   %e0, %1");
4534 #line 626 "rl78-decode.opc"
4535           ID(mov); DM(HL, 0); SR(A);
4536
4537         }
4538       break;
4539     case 0x9c:
4540         {
4541           /** 1001 1100                 mov     %ea0, %1                        */
4542           if (trace)
4543             {
4544               printf ("\033[33m%s\033[0m  %02x\n",
4545                      "/** 1001 1100                     mov     %ea0, %1                        */",
4546                      op[0]);
4547             }
4548           SYNTAX("mov   %ea0, %1");
4549 #line 635 "rl78-decode.opc"
4550           ID(mov); DM(HL, IMMU(1)); SR(A);
4551
4552         }
4553       break;
4554     case 0x9d:
4555         {
4556           /** 1001 1101                 mov     %0, %1                          */
4557           if (trace)
4558             {
4559               printf ("\033[33m%s\033[0m  %02x\n",
4560                      "/** 1001 1101                     mov     %0, %1                          */",
4561                      op[0]);
4562             }
4563           SYNTAX("mov   %0, %1");
4564 #line 749 "rl78-decode.opc"
4565           ID(mov); DM(None, SADDR); SR(A);
4566
4567         }
4568       break;
4569     case 0x9e:
4570         {
4571           /** 1001 1110                 mov     %s0, %1                         */
4572           if (trace)
4573             {
4574               printf ("\033[33m%s\033[0m  %02x\n",
4575                      "/** 1001 1110                     mov     %s0, %1                         */",
4576                      op[0]);
4577             }
4578           SYNTAX("mov   %s0, %1");
4579 #line 782 "rl78-decode.opc"
4580           ID(mov); DM(None, SFR); SR(A);
4581
4582         /*----------------------------------------------------------------------*/
4583
4584         }
4585       break;
4586     case 0x9f:
4587         {
4588           /** 1001 1111                 mov     %e!0, %1                        */
4589           if (trace)
4590             {
4591               printf ("\033[33m%s\033[0m  %02x\n",
4592                      "/** 1001 1111                     mov     %e!0, %1                        */",
4593                      op[0]);
4594             }
4595           SYNTAX("mov   %e!0, %1");
4596 #line 614 "rl78-decode.opc"
4597           ID(mov); DM(None, IMMU(2)); SR(A);
4598
4599         }
4600       break;
4601     case 0xa0:
4602         {
4603           /** 1010 0000                 inc     %e!0                            */
4604           if (trace)
4605             {
4606               printf ("\033[33m%s\033[0m  %02x\n",
4607                      "/** 1010 0000                     inc     %e!0                            */",
4608                      op[0]);
4609             }
4610           SYNTAX("inc   %e!0");
4611 #line 583 "rl78-decode.opc"
4612           ID(add); DM(None, IMMU(2)); SC(1); Fza;
4613
4614         }
4615       break;
4616     case 0xa1:
4617     case 0xa3:
4618     case 0xa5:
4619     case 0xa7:
4620         {
4621           /** 1010 0rg1                 incw    %0                              */
4622 #line 603 "rl78-decode.opc"
4623           int rg AU = (op[0] >> 1) & 0x03;
4624           if (trace)
4625             {
4626               printf ("\033[33m%s\033[0m  %02x\n",
4627                      "/** 1010 0rg1                     incw    %0                              */",
4628                      op[0]);
4629               printf ("  rg = 0x%x\n", rg);
4630             }
4631           SYNTAX("incw  %0");
4632 #line 603 "rl78-decode.opc"
4633           ID(add); W(); DRW(rg); SC(1);
4634
4635         }
4636       break;
4637     case 0xa2:
4638         {
4639           /** 1010 0010                 incw    %e!0                            */
4640           if (trace)
4641             {
4642               printf ("\033[33m%s\033[0m  %02x\n",
4643                      "/** 1010 0010                     incw    %e!0                            */",
4644                      op[0]);
4645             }
4646           SYNTAX("incw  %e!0");
4647 #line 597 "rl78-decode.opc"
4648           ID(add); W(); DM(None, IMMU(2)); SC(1);
4649
4650         }
4651       break;
4652     case 0xa4:
4653         {
4654           /** 1010 0100                 inc     %0                              */
4655           if (trace)
4656             {
4657               printf ("\033[33m%s\033[0m  %02x\n",
4658                      "/** 1010 0100                     inc     %0                              */",
4659                      op[0]);
4660             }
4661           SYNTAX("inc   %0");
4662 #line 592 "rl78-decode.opc"
4663           ID(add); DM(None, SADDR); SC(1); Fza;
4664
4665         /*----------------------------------------------------------------------*/
4666
4667         }
4668       break;
4669     case 0xa6:
4670         {
4671           /** 1010 0110                 incw    %0                              */
4672           if (trace)
4673             {
4674               printf ("\033[33m%s\033[0m  %02x\n",
4675                      "/** 1010 0110                     incw    %0                              */",
4676                      op[0]);
4677             }
4678           SYNTAX("incw  %0");
4679 #line 606 "rl78-decode.opc"
4680           ID(add); W(); DM(None, SADDR); SC(1);
4681
4682         /*----------------------------------------------------------------------*/
4683
4684         }
4685       break;
4686     case 0xa8:
4687         {
4688           /** 1010 1000                 movw    %0, %a1                         */
4689           if (trace)
4690             {
4691               printf ("\033[33m%s\033[0m  %02x\n",
4692                      "/** 1010 1000                     movw    %0, %a1                         */",
4693                      op[0]);
4694             }
4695           SYNTAX("movw  %0, %a1");
4696 #line 852 "rl78-decode.opc"
4697           ID(mov); W(); DR(AX); SM(SP, IMMU(1));
4698
4699         }
4700       break;
4701     case 0xa9:
4702         {
4703           /** 1010 1001                 movw    %0, %e1                         */
4704           if (trace)
4705             {
4706               printf ("\033[33m%s\033[0m  %02x\n",
4707                      "/** 1010 1001                     movw    %0, %e1                         */",
4708                      op[0]);
4709             }
4710           SYNTAX("movw  %0, %e1");
4711 #line 840 "rl78-decode.opc"
4712           ID(mov); W(); DR(AX); SM(DE, 0);
4713
4714         }
4715       break;
4716     case 0xaa:
4717         {
4718           /** 1010 1010                 movw    %0, %ea1                                */
4719           if (trace)
4720             {
4721               printf ("\033[33m%s\033[0m  %02x\n",
4722                      "/** 1010 1010                     movw    %0, %ea1                                */",
4723                      op[0]);
4724             }
4725           SYNTAX("movw  %0, %ea1");
4726 #line 843 "rl78-decode.opc"
4727           ID(mov); W(); DR(AX); SM(DE, IMMU(1));
4728
4729         }
4730       break;
4731     case 0xab:
4732         {
4733           /** 1010 1011                 movw    %0, %e1                         */
4734           if (trace)
4735             {
4736               printf ("\033[33m%s\033[0m  %02x\n",
4737                      "/** 1010 1011                     movw    %0, %e1                         */",
4738                      op[0]);
4739             }
4740           SYNTAX("movw  %0, %e1");
4741 #line 846 "rl78-decode.opc"
4742           ID(mov); W(); DR(AX); SM(HL, 0);
4743
4744         }
4745       break;
4746     case 0xac:
4747         {
4748           /** 1010 1100                 movw    %0, %ea1                        */
4749           if (trace)
4750             {
4751               printf ("\033[33m%s\033[0m  %02x\n",
4752                      "/** 1010 1100                     movw    %0, %ea1                        */",
4753                      op[0]);
4754             }
4755           SYNTAX("movw  %0, %ea1");
4756 #line 849 "rl78-decode.opc"
4757           ID(mov); W(); DR(AX); SM(HL, IMMU(1));
4758
4759         }
4760       break;
4761     case 0xad:
4762         {
4763           /** 1010 1101                 movw    %0, %1                          */
4764           if (trace)
4765             {
4766               printf ("\033[33m%s\033[0m  %02x\n",
4767                      "/** 1010 1101                     movw    %0, %1                          */",
4768                      op[0]);
4769             }
4770           SYNTAX("movw  %0, %1");
4771 #line 882 "rl78-decode.opc"
4772           ID(mov); W(); DR(AX); SM(None, SADDR);
4773
4774         }
4775       break;
4776     case 0xae:
4777         {
4778           /** 1010 1110                 movw    %0, %s1                         */
4779           if (trace)
4780             {
4781               printf ("\033[33m%s\033[0m  %02x\n",
4782                      "/** 1010 1110                     movw    %0, %s1                         */",
4783                      op[0]);
4784             }
4785           SYNTAX("movw  %0, %s1");
4786 #line 885 "rl78-decode.opc"
4787           ID(mov); W(); DR(AX); SM(None, SFR);
4788
4789         }
4790       break;
4791     case 0xaf:
4792         {
4793           /** 1010 1111                 movw    %0, %e!1                        */
4794           if (trace)
4795             {
4796               printf ("\033[33m%s\033[0m  %02x\n",
4797                      "/** 1010 1111                     movw    %0, %e!1                        */",
4798                      op[0]);
4799             }
4800           SYNTAX("movw  %0, %e!1");
4801 #line 836 "rl78-decode.opc"
4802           ID(mov); W(); DR(AX); SM(None, IMMU(2));
4803
4804
4805         }
4806       break;
4807     case 0xb0:
4808         {
4809           /** 1011 0000                 dec     %e!0                            */
4810           if (trace)
4811             {
4812               printf ("\033[33m%s\033[0m  %02x\n",
4813                      "/** 1011 0000                     dec     %e!0                            */",
4814                      op[0]);
4815             }
4816           SYNTAX("dec   %e!0");
4817 #line 550 "rl78-decode.opc"
4818           ID(sub); DM(None, IMMU(2)); SC(1); Fza;
4819
4820         }
4821       break;
4822     case 0xb1:
4823     case 0xb3:
4824     case 0xb5:
4825     case 0xb7:
4826         {
4827           /** 1011 0rg1                         decw    %0                              */
4828 #line 570 "rl78-decode.opc"
4829           int rg AU = (op[0] >> 1) & 0x03;
4830           if (trace)
4831             {
4832               printf ("\033[33m%s\033[0m  %02x\n",
4833                      "/** 1011 0rg1                     decw    %0                              */",
4834                      op[0]);
4835               printf ("  rg = 0x%x\n", rg);
4836             }
4837           SYNTAX("decw  %0");
4838 #line 570 "rl78-decode.opc"
4839           ID(sub); W(); DRW(rg); SC(1);
4840
4841         }
4842       break;
4843     case 0xb2:
4844         {
4845           /** 1011 0010                 decw    %e!0                            */
4846           if (trace)
4847             {
4848               printf ("\033[33m%s\033[0m  %02x\n",
4849                      "/** 1011 0010                     decw    %e!0                            */",
4850                      op[0]);
4851             }
4852           SYNTAX("decw  %e!0");
4853 #line 564 "rl78-decode.opc"
4854           ID(sub); W(); DM(None, IMMU(2)); SC(1);
4855
4856         }
4857       break;
4858     case 0xb4:
4859         {
4860           /** 1011 0100                 dec     %0                              */
4861           if (trace)
4862             {
4863               printf ("\033[33m%s\033[0m  %02x\n",
4864                      "/** 1011 0100                     dec     %0                              */",
4865                      op[0]);
4866             }
4867           SYNTAX("dec   %0");
4868 #line 559 "rl78-decode.opc"
4869           ID(sub); DM(None, SADDR); SC(1); Fza;
4870
4871         /*----------------------------------------------------------------------*/
4872
4873         }
4874       break;
4875     case 0xb6:
4876         {
4877           /** 1011 0110                 decw    %0                              */
4878           if (trace)
4879             {
4880               printf ("\033[33m%s\033[0m  %02x\n",
4881                      "/** 1011 0110                     decw    %0                              */",
4882                      op[0]);
4883             }
4884           SYNTAX("decw  %0");
4885 #line 573 "rl78-decode.opc"
4886           ID(sub); W(); DM(None, SADDR); SC(1);
4887
4888         /*----------------------------------------------------------------------*/
4889
4890         }
4891       break;
4892     case 0xb8:
4893         {
4894           /** 1011 1000                 movw    %a0, %1                         */
4895           if (trace)
4896             {
4897               printf ("\033[33m%s\033[0m  %02x\n",
4898                      "/** 1011 1000                     movw    %a0, %1                         */",
4899                      op[0]);
4900             }
4901           SYNTAX("movw  %a0, %1");
4902 #line 833 "rl78-decode.opc"
4903           ID(mov); W(); DM(SP, IMMU(1)); SR(AX);
4904
4905         }
4906       break;
4907     case 0xb9:
4908         {
4909           /** 1011 1001                 movw    %e0, %1                         */
4910           if (trace)
4911             {
4912               printf ("\033[33m%s\033[0m  %02x\n",
4913                      "/** 1011 1001                     movw    %e0, %1                         */",
4914                      op[0]);
4915             }
4916           SYNTAX("movw  %e0, %1");
4917 #line 821 "rl78-decode.opc"
4918           ID(mov); W(); DM(DE, 0); SR(AX);
4919
4920         }
4921       break;
4922     case 0xba:
4923         {
4924           /** 1011 1010                 movw    %ea0, %1                                */
4925           if (trace)
4926             {
4927               printf ("\033[33m%s\033[0m  %02x\n",
4928                      "/** 1011 1010                     movw    %ea0, %1                                */",
4929                      op[0]);
4930             }
4931           SYNTAX("movw  %ea0, %1");
4932 #line 824 "rl78-decode.opc"
4933           ID(mov); W(); DM(DE, IMMU(1)); SR(AX);
4934
4935         }
4936       break;
4937     case 0xbb:
4938         {
4939           /** 1011 1011                 movw    %e0, %1                         */
4940           if (trace)
4941             {
4942               printf ("\033[33m%s\033[0m  %02x\n",
4943                      "/** 1011 1011                     movw    %e0, %1                         */",
4944                      op[0]);
4945             }
4946           SYNTAX("movw  %e0, %1");
4947 #line 827 "rl78-decode.opc"
4948           ID(mov); W(); DM(HL, 0); SR(AX);
4949
4950         }
4951       break;
4952     case 0xbc:
4953         {
4954           /** 1011 1100                 movw    %ea0, %1                        */
4955           if (trace)
4956             {
4957               printf ("\033[33m%s\033[0m  %02x\n",
4958                      "/** 1011 1100                     movw    %ea0, %1                        */",
4959                      op[0]);
4960             }
4961           SYNTAX("movw  %ea0, %1");
4962 #line 830 "rl78-decode.opc"
4963           ID(mov); W(); DM(HL, IMMU(1)); SR(AX);
4964
4965         }
4966       break;
4967     case 0xbd:
4968         {
4969           /** 1011 1101                 movw    %0, %1                          */
4970           if (trace)
4971             {
4972               printf ("\033[33m%s\033[0m  %02x\n",
4973                      "/** 1011 1101                     movw    %0, %1                          */",
4974                      op[0]);
4975             }
4976           SYNTAX("movw  %0, %1");
4977 #line 897 "rl78-decode.opc"
4978           ID(mov); W(); DM(None, SADDR); SR(AX);
4979
4980         }
4981       break;
4982     case 0xbe:
4983         {
4984           /** 1011 1110                 movw    %s0, %1                         */
4985           if (trace)
4986             {
4987               printf ("\033[33m%s\033[0m  %02x\n",
4988                      "/** 1011 1110                     movw    %s0, %1                         */",
4989                      op[0]);
4990             }
4991           SYNTAX("movw  %s0, %1");
4992 #line 903 "rl78-decode.opc"
4993           ID(mov); W(); DM(None, SFR); SR(AX);
4994
4995         /*----------------------------------------------------------------------*/
4996
4997         }
4998       break;
4999     case 0xbf:
5000         {
5001           /** 1011 1111                 movw    %e!0, %1                        */
5002           if (trace)
5003             {
5004               printf ("\033[33m%s\033[0m  %02x\n",
5005                      "/** 1011 1111                     movw    %e!0, %1                        */",
5006                      op[0]);
5007             }
5008           SYNTAX("movw  %e!0, %1");
5009 #line 818 "rl78-decode.opc"
5010           ID(mov); W(); DM(None, IMMU(2)); SR(AX);
5011
5012         }
5013       break;
5014     case 0xc0:
5015     case 0xc2:
5016     case 0xc4:
5017     case 0xc6:
5018         {
5019           /** 1100 0rg0                 pop     %0                              */
5020 #line 988 "rl78-decode.opc"
5021           int rg AU = (op[0] >> 1) & 0x03;
5022           if (trace)
5023             {
5024               printf ("\033[33m%s\033[0m  %02x\n",
5025                      "/** 1100 0rg0                     pop     %0                              */",
5026                      op[0]);
5027               printf ("  rg = 0x%x\n", rg);
5028             }
5029           SYNTAX("pop   %0");
5030 #line 988 "rl78-decode.opc"
5031           ID(mov); W(); DRW(rg); SPOP();
5032
5033         }
5034       break;
5035     case 0xc1:
5036     case 0xc3:
5037     case 0xc5:
5038     case 0xc7:
5039         {
5040           /** 1100 0rg1                 push    %1                              */
5041 #line 996 "rl78-decode.opc"
5042           int rg AU = (op[0] >> 1) & 0x03;
5043           if (trace)
5044             {
5045               printf ("\033[33m%s\033[0m  %02x\n",
5046                      "/** 1100 0rg1                     push    %1                              */",
5047                      op[0]);
5048               printf ("  rg = 0x%x\n", rg);
5049             }
5050           SYNTAX("push  %1");
5051 #line 996 "rl78-decode.opc"
5052           ID(mov); W(); DPUSH(); SRW(rg);
5053
5054         }
5055       break;
5056     case 0xc8:
5057         {
5058           /** 1100 1000                 mov     %a0, #%1                        */
5059           if (trace)
5060             {
5061               printf ("\033[33m%s\033[0m  %02x\n",
5062                      "/** 1100 1000                     mov     %a0, #%1                        */",
5063                      op[0]);
5064             }
5065           SYNTAX("mov   %a0, #%1");
5066 #line 641 "rl78-decode.opc"
5067           ID(mov); DM(SP, IMMU(1)); SC(IMMU(1));
5068
5069         }
5070       break;
5071     case 0xc9:
5072         {
5073           /** 1100 1001                 movw    %0, #%1                         */
5074           if (trace)
5075             {
5076               printf ("\033[33m%s\033[0m  %02x\n",
5077                      "/** 1100 1001                     movw    %0, #%1                         */",
5078                      op[0]);
5079             }
5080           SYNTAX("movw  %0, #%1");
5081 #line 894 "rl78-decode.opc"
5082           ID(mov); W(); DM(None, SADDR); SC(IMMU(2));
5083
5084         }
5085       break;
5086     case 0xca:
5087         {
5088           /** 1100 1010                 mov     %ea0, #%1                       */
5089           if (trace)
5090             {
5091               printf ("\033[33m%s\033[0m  %02x\n",
5092                      "/** 1100 1010                     mov     %ea0, #%1                       */",
5093                      op[0]);
5094             }
5095           SYNTAX("mov   %ea0, #%1");
5096 #line 620 "rl78-decode.opc"
5097           ID(mov); DM(DE, IMMU(1)); SC(IMMU(1));
5098
5099         }
5100       break;
5101     case 0xcb:
5102         {
5103           /** 1100 1011                 movw    %s0, #%1                        */
5104           if (trace)
5105             {
5106               printf ("\033[33m%s\033[0m  %02x\n",
5107                      "/** 1100 1011                     movw    %s0, #%1                        */",
5108                      op[0]);
5109             }
5110           SYNTAX("movw  %s0, #%1");
5111 #line 900 "rl78-decode.opc"
5112           ID(mov); W(); DM(None, SFR); SC(IMMU(2));
5113
5114         }
5115       break;
5116     case 0xcc:
5117         {
5118           /** 1100 1100                 mov     %ea0, #%1                       */
5119           if (trace)
5120             {
5121               printf ("\033[33m%s\033[0m  %02x\n",
5122                      "/** 1100 1100                     mov     %ea0, #%1                       */",
5123                      op[0]);
5124             }
5125           SYNTAX("mov   %ea0, #%1");
5126 #line 632 "rl78-decode.opc"
5127           ID(mov); DM(HL, IMMU(1)); SC(IMMU(1));
5128
5129         }
5130       break;
5131     case 0xcd:
5132         {
5133           /** 1100 1101                 mov     %0, #%1                         */
5134           if (trace)
5135             {
5136               printf ("\033[33m%s\033[0m  %02x\n",
5137                      "/** 1100 1101                     mov     %0, #%1                         */",
5138                      op[0]);
5139             }
5140           SYNTAX("mov   %0, #%1");
5141 #line 746 "rl78-decode.opc"
5142           ID(mov); DM(None, SADDR); SC(IMMU(1));
5143
5144         }
5145       break;
5146     case 0xce:
5147         {
5148           /** 1100 1110                 mov     %s0, #%1                        */
5149           if (trace)
5150             {
5151               printf ("\033[33m%s\033[0m  %02x\n",
5152                      "/** 1100 1110                     mov     %s0, #%1                        */",
5153                      op[0]);
5154             }
5155           SYNTAX("mov   %s0, #%1");
5156 #line 752 "rl78-decode.opc"
5157           op0 = SFR;
5158           op1 = IMMU(1);
5159           ID(mov); DM(None, op0); SC(op1);
5160           if (op0 == 0xffffb && isa == RL78_ISA_G14)
5161             switch (op1)
5162               {
5163               case 0x01:
5164                 rl78->syntax = "mulhu"; ID(mulhu);
5165                 break;
5166               case 0x02:
5167                 rl78->syntax = "mulh"; ID(mulh);
5168                 break;
5169               case 0x03:
5170                 rl78->syntax = "divhu"; ID(divhu);
5171                 break;
5172               case 0x04:
5173                 rl78->syntax = "divwu <old-encoding>"; ID(divwu);
5174                 break;
5175               case 0x05:
5176                 rl78->syntax = "machu"; ID(machu);
5177                 break;
5178               case 0x06:
5179                 rl78->syntax = "mach"; ID(mach);
5180                 break;
5181               case 0x0b:
5182                 rl78->syntax = "divwu"; ID(divwu);
5183                 break;
5184               }
5185
5186         }
5187       break;
5188     case 0xcf:
5189         {
5190           /** 1100 1111                 mov     %e!0, #%1                       */
5191           if (trace)
5192             {
5193               printf ("\033[33m%s\033[0m  %02x\n",
5194                      "/** 1100 1111                     mov     %e!0, #%1                       */",
5195                      op[0]);
5196             }
5197           SYNTAX("mov   %e!0, #%1");
5198 #line 611 "rl78-decode.opc"
5199           ID(mov); DM(None, IMMU(2)); SC(IMMU(1));
5200
5201         }
5202       break;
5203     case 0xd0:
5204     case 0xd1:
5205     case 0xd2:
5206     case 0xd3:
5207         {
5208           /** 1101 00rg                 cmp0    %0                              */
5209 #line 520 "rl78-decode.opc"
5210           int rg AU = op[0] & 0x03;
5211           if (trace)
5212             {
5213               printf ("\033[33m%s\033[0m  %02x\n",
5214                      "/** 1101 00rg                     cmp0    %0                              */",
5215                      op[0]);
5216               printf ("  rg = 0x%x\n", rg);
5217             }
5218           SYNTAX("cmp0  %0");
5219 #line 520 "rl78-decode.opc"
5220           ID(cmp); DRB(rg); SC(0); Fzac;
5221
5222         }
5223       break;
5224     case 0xd4:
5225         {
5226           /** 1101 0100                 cmp0    %0                              */
5227           if (trace)
5228             {
5229               printf ("\033[33m%s\033[0m  %02x\n",
5230                      "/** 1101 0100                     cmp0    %0                              */",
5231                      op[0]);
5232             }
5233           SYNTAX("cmp0  %0");
5234 #line 523 "rl78-decode.opc"
5235           ID(cmp); DM(None, SADDR); SC(0); Fzac;
5236
5237         /*----------------------------------------------------------------------*/
5238
5239         }
5240       break;
5241     case 0xd5:
5242         {
5243           /** 1101 0101                 cmp0    %e!0                            */
5244           if (trace)
5245             {
5246               printf ("\033[33m%s\033[0m  %02x\n",
5247                      "/** 1101 0101                     cmp0    %e!0                            */",
5248                      op[0]);
5249             }
5250           SYNTAX("cmp0  %e!0");
5251 #line 517 "rl78-decode.opc"
5252           ID(cmp); DM(None, IMMU(2)); SC(0); Fzac;
5253
5254         }
5255       break;
5256     case 0xd6:
5257         {
5258           /** 1101 0110                 mulu    x                               */
5259           if (trace)
5260             {
5261               printf ("\033[33m%s\033[0m  %02x\n",
5262                      "/** 1101 0110                     mulu    x                               */",
5263                      op[0]);
5264             }
5265           SYNTAX("mulu  x");
5266 #line 908 "rl78-decode.opc"
5267           ID(mulu);
5268
5269         /*----------------------------------------------------------------------*/
5270
5271         }
5272       break;
5273     case 0xd7:
5274         {
5275           /** 1101 0111                 ret                                     */
5276           if (trace)
5277             {
5278               printf ("\033[33m%s\033[0m  %02x\n",
5279                      "/** 1101 0111                     ret                                     */",
5280                      op[0]);
5281             }
5282           SYNTAX("ret");
5283 #line 1004 "rl78-decode.opc"
5284           ID(ret);
5285
5286         }
5287       break;
5288     case 0xd8:
5289         {
5290           /** 1101 1000                 mov     %0, %1                          */
5291           if (trace)
5292             {
5293               printf ("\033[33m%s\033[0m  %02x\n",
5294                      "/** 1101 1000                     mov     %0, %1                          */",
5295                      op[0]);
5296             }
5297           SYNTAX("mov   %0, %1");
5298 #line 713 "rl78-decode.opc"
5299           ID(mov); DR(X); SM(None, SADDR);
5300
5301         }
5302       break;
5303     case 0xd9:
5304         {
5305           /** 1101 1001                 mov     %0, %e!1                        */
5306           if (trace)
5307             {
5308               printf ("\033[33m%s\033[0m  %02x\n",
5309                      "/** 1101 1001                     mov     %0, %e!1                        */",
5310                      op[0]);
5311             }
5312           SYNTAX("mov   %0, %e!1");
5313 #line 710 "rl78-decode.opc"
5314           ID(mov); DR(X); SM(None, IMMU(2));
5315
5316         }
5317       break;
5318     case 0xda:
5319     case 0xea:
5320     case 0xfa:
5321         {
5322           /** 11ra 1010                 movw    %0, %1                          */
5323 #line 891 "rl78-decode.opc"
5324           int ra AU = (op[0] >> 4) & 0x03;
5325           if (trace)
5326             {
5327               printf ("\033[33m%s\033[0m  %02x\n",
5328                      "/** 11ra 1010                     movw    %0, %1                          */",
5329                      op[0]);
5330               printf ("  ra = 0x%x\n", ra);
5331             }
5332           SYNTAX("movw  %0, %1");
5333 #line 891 "rl78-decode.opc"
5334           ID(mov); W(); DRW(ra); SM(None, SADDR);
5335
5336         }
5337       break;
5338     case 0xdb:
5339     case 0xeb:
5340     case 0xfb:
5341         {
5342           /** 11ra 1011                 movw    %0, %es!1                       */
5343 #line 888 "rl78-decode.opc"
5344           int ra AU = (op[0] >> 4) & 0x03;
5345           if (trace)
5346             {
5347               printf ("\033[33m%s\033[0m  %02x\n",
5348                      "/** 11ra 1011                     movw    %0, %es!1                       */",
5349                      op[0]);
5350               printf ("  ra = 0x%x\n", ra);
5351             }
5352           SYNTAX("movw  %0, %es!1");
5353 #line 888 "rl78-decode.opc"
5354           ID(mov); W(); DRW(ra); SM(None, IMMU(2));
5355
5356         }
5357       break;
5358     case 0xdc:
5359         {
5360           /** 1101 1100                 bc      $%a0                            */
5361           if (trace)
5362             {
5363               printf ("\033[33m%s\033[0m  %02x\n",
5364                      "/** 1101 1100                     bc      $%a0                            */",
5365                      op[0]);
5366             }
5367           SYNTAX("bc    $%a0");
5368 #line 336 "rl78-decode.opc"
5369           ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(C);
5370
5371         }
5372       break;
5373     case 0xdd:
5374         {
5375           /** 1101 1101                 bz      $%a0                            */
5376           if (trace)
5377             {
5378               printf ("\033[33m%s\033[0m  %02x\n",
5379                      "/** 1101 1101                     bz      $%a0                            */",
5380                      op[0]);
5381             }
5382           SYNTAX("bz    $%a0");
5383 #line 348 "rl78-decode.opc"
5384           ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(Z);
5385
5386         }
5387       break;
5388     case 0xde:
5389         {
5390           /** 1101 1110                 bnc     $%a0                            */
5391           if (trace)
5392             {
5393               printf ("\033[33m%s\033[0m  %02x\n",
5394                      "/** 1101 1110                     bnc     $%a0                            */",
5395                      op[0]);
5396             }
5397           SYNTAX("bnc   $%a0");
5398 #line 339 "rl78-decode.opc"
5399           ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(NC);
5400
5401         }
5402       break;
5403     case 0xdf:
5404         {
5405           /** 1101 1111                 bnz     $%a0                            */
5406           if (trace)
5407             {
5408               printf ("\033[33m%s\033[0m  %02x\n",
5409                      "/** 1101 1111                     bnz     $%a0                            */",
5410                      op[0]);
5411             }
5412           SYNTAX("bnz   $%a0");
5413 #line 351 "rl78-decode.opc"
5414           ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(NZ);
5415
5416         /*----------------------------------------------------------------------*/
5417
5418         }
5419       break;
5420     case 0xe0:
5421     case 0xe1:
5422     case 0xe2:
5423     case 0xe3:
5424         {
5425           /** 1110 00rg                 oneb    %0                              */
5426 #line 926 "rl78-decode.opc"
5427           int rg AU = op[0] & 0x03;
5428           if (trace)
5429             {
5430               printf ("\033[33m%s\033[0m  %02x\n",
5431                      "/** 1110 00rg                     oneb    %0                              */",
5432                      op[0]);
5433               printf ("  rg = 0x%x\n", rg);
5434             }
5435           SYNTAX("oneb  %0");
5436 #line 926 "rl78-decode.opc"
5437           ID(mov); DRB(rg); SC(1);
5438
5439         }
5440       break;
5441     case 0xe4:
5442         {
5443           /** 1110 0100                 oneb    %0                              */
5444           if (trace)
5445             {
5446               printf ("\033[33m%s\033[0m  %02x\n",
5447                      "/** 1110 0100                     oneb    %0                              */",
5448                      op[0]);
5449             }
5450           SYNTAX("oneb  %0");
5451 #line 929 "rl78-decode.opc"
5452           ID(mov); DM(None, SADDR); SC(1);
5453
5454         /*----------------------------------------------------------------------*/
5455
5456         }
5457       break;
5458     case 0xe5:
5459         {
5460           /** 1110 0101                 oneb    %e!0                            */
5461           if (trace)
5462             {
5463               printf ("\033[33m%s\033[0m  %02x\n",
5464                      "/** 1110 0101                     oneb    %e!0                            */",
5465                      op[0]);
5466             }
5467           SYNTAX("oneb  %e!0");
5468 #line 923 "rl78-decode.opc"
5469           ID(mov); DM(None, IMMU(2)); SC(1);
5470
5471         }
5472       break;
5473     case 0xe6:
5474         {
5475           /** 1110 0110                 onew    %0                              */
5476           if (trace)
5477             {
5478               printf ("\033[33m%s\033[0m  %02x\n",
5479                      "/** 1110 0110                     onew    %0                              */",
5480                      op[0]);
5481             }
5482           SYNTAX("onew  %0");
5483 #line 934 "rl78-decode.opc"
5484           ID(mov); DR(AX); SC(1);
5485
5486         }
5487       break;
5488     case 0xe7:
5489         {
5490           /** 1110 0111                 onew    %0                              */
5491           if (trace)
5492             {
5493               printf ("\033[33m%s\033[0m  %02x\n",
5494                      "/** 1110 0111                     onew    %0                              */",
5495                      op[0]);
5496             }
5497           SYNTAX("onew  %0");
5498 #line 937 "rl78-decode.opc"
5499           ID(mov); DR(BC); SC(1);
5500
5501         /*----------------------------------------------------------------------*/
5502
5503         }
5504       break;
5505     case 0xe8:
5506         {
5507           /** 1110 1000                 mov     %0, %1                          */
5508           if (trace)
5509             {
5510               printf ("\033[33m%s\033[0m  %02x\n",
5511                      "/** 1110 1000                     mov     %0, %1                          */",
5512                      op[0]);
5513             }
5514           SYNTAX("mov   %0, %1");
5515 #line 701 "rl78-decode.opc"
5516           ID(mov); DR(B); SM(None, SADDR);
5517
5518         }
5519       break;
5520     case 0xe9:
5521         {
5522           /** 1110 1001                 mov     %0, %e!1                        */
5523           if (trace)
5524             {
5525               printf ("\033[33m%s\033[0m  %02x\n",
5526                      "/** 1110 1001                     mov     %0, %e!1                        */",
5527                      op[0]);
5528             }
5529           SYNTAX("mov   %0, %e!1");
5530 #line 695 "rl78-decode.opc"
5531           ID(mov); DR(B); SM(None, IMMU(2));
5532
5533         }
5534       break;
5535     case 0xec:
5536         {
5537           /** 1110 1100                 br      !%!a0                           */
5538           if (trace)
5539             {
5540               printf ("\033[33m%s\033[0m  %02x\n",
5541                      "/** 1110 1100                     br      !%!a0                           */",
5542                      op[0]);
5543             }
5544           SYNTAX("br    !%!a0");
5545 #line 370 "rl78-decode.opc"
5546           ID(branch); DC(IMMU(3));
5547
5548         }
5549       break;
5550     case 0xed:
5551         {
5552           /** 1110 1101                 br      %!a0                            */
5553           if (trace)
5554             {
5555               printf ("\033[33m%s\033[0m  %02x\n",
5556                      "/** 1110 1101                     br      %!a0                            */",
5557                      op[0]);
5558             }
5559           SYNTAX("br    %!a0");
5560 #line 373 "rl78-decode.opc"
5561           ID(branch); DC(IMMU(2));
5562
5563         }
5564       break;
5565     case 0xee:
5566         {
5567           /** 1110 1110                 br      $%!a0                           */
5568           if (trace)
5569             {
5570               printf ("\033[33m%s\033[0m  %02x\n",
5571                      "/** 1110 1110                     br      $%!a0                           */",
5572                      op[0]);
5573             }
5574           SYNTAX("br    $%!a0");
5575 #line 376 "rl78-decode.opc"
5576           ID(branch); DC(pc+IMMS(2)+3);
5577
5578         }
5579       break;
5580     case 0xef:
5581         {
5582           /** 1110 1111                 br      $%a0                            */
5583           if (trace)
5584             {
5585               printf ("\033[33m%s\033[0m  %02x\n",
5586                      "/** 1110 1111                     br      $%a0                            */",
5587                      op[0]);
5588             }
5589           SYNTAX("br    $%a0");
5590 #line 379 "rl78-decode.opc"
5591           ID(branch); DC(pc+IMMS(1)+2);
5592
5593         }
5594       break;
5595     case 0xf0:
5596     case 0xf1:
5597     case 0xf2:
5598     case 0xf3:
5599         {
5600           /** 1111 00rg                 clrb    %0                              */
5601 #line 466 "rl78-decode.opc"
5602           int rg AU = op[0] & 0x03;
5603           if (trace)
5604             {
5605               printf ("\033[33m%s\033[0m  %02x\n",
5606                      "/** 1111 00rg                     clrb    %0                              */",
5607                      op[0]);
5608               printf ("  rg = 0x%x\n", rg);
5609             }
5610           SYNTAX("clrb  %0");
5611 #line 466 "rl78-decode.opc"
5612           ID(mov); DRB(rg); SC(0);
5613
5614         }
5615       break;
5616     case 0xf4:
5617         {
5618           /** 1111 0100                 clrb    %0                              */
5619           if (trace)
5620             {
5621               printf ("\033[33m%s\033[0m  %02x\n",
5622                      "/** 1111 0100                     clrb    %0                              */",
5623                      op[0]);
5624             }
5625           SYNTAX("clrb  %0");
5626 #line 469 "rl78-decode.opc"
5627           ID(mov); DM(None, SADDR); SC(0);
5628
5629         /*----------------------------------------------------------------------*/
5630
5631         }
5632       break;
5633     case 0xf5:
5634         {
5635           /** 1111 0101                 clrb    %e!0                            */
5636           if (trace)
5637             {
5638               printf ("\033[33m%s\033[0m  %02x\n",
5639                      "/** 1111 0101                     clrb    %e!0                            */",
5640                      op[0]);
5641             }
5642           SYNTAX("clrb  %e!0");
5643 #line 463 "rl78-decode.opc"
5644           ID(mov); DM(None, IMMU(2)); SC(0);
5645
5646         }
5647       break;
5648     case 0xf6:
5649         {
5650           /** 1111 0110                 clrw    %0                              */
5651           if (trace)
5652             {
5653               printf ("\033[33m%s\033[0m  %02x\n",
5654                      "/** 1111 0110                     clrw    %0                              */",
5655                      op[0]);
5656             }
5657           SYNTAX("clrw  %0");
5658 #line 474 "rl78-decode.opc"
5659           ID(mov); DR(AX); SC(0);
5660
5661         }
5662       break;
5663     case 0xf7:
5664         {
5665           /** 1111 0111                 clrw    %0                              */
5666           if (trace)
5667             {
5668               printf ("\033[33m%s\033[0m  %02x\n",
5669                      "/** 1111 0111                     clrw    %0                              */",
5670                      op[0]);
5671             }
5672           SYNTAX("clrw  %0");
5673 #line 477 "rl78-decode.opc"
5674           ID(mov); DR(BC); SC(0);
5675
5676         /*----------------------------------------------------------------------*/
5677
5678         }
5679       break;
5680     case 0xf8:
5681         {
5682           /** 1111 1000                 mov     %0, %1                          */
5683           if (trace)
5684             {
5685               printf ("\033[33m%s\033[0m  %02x\n",
5686                      "/** 1111 1000                     mov     %0, %1                          */",
5687                      op[0]);
5688             }
5689           SYNTAX("mov   %0, %1");
5690 #line 707 "rl78-decode.opc"
5691           ID(mov); DR(C); SM(None, SADDR);
5692
5693         }
5694       break;
5695     case 0xf9:
5696         {
5697           /** 1111 1001                 mov     %0, %e!1                        */
5698           if (trace)
5699             {
5700               printf ("\033[33m%s\033[0m  %02x\n",
5701                      "/** 1111 1001                     mov     %0, %e!1                        */",
5702                      op[0]);
5703             }
5704           SYNTAX("mov   %0, %e!1");
5705 #line 704 "rl78-decode.opc"
5706           ID(mov); DR(C); SM(None, IMMU(2));
5707
5708         }
5709       break;
5710     case 0xfc:
5711         {
5712           /** 1111 1100                 call    !%!a0                           */
5713           if (trace)
5714             {
5715               printf ("\033[33m%s\033[0m  %02x\n",
5716                      "/** 1111 1100                     call    !%!a0                           */",
5717                      op[0]);
5718             }
5719           SYNTAX("call  !%!a0");
5720 #line 423 "rl78-decode.opc"
5721           ID(call); DC(IMMU(3));
5722
5723         }
5724       break;
5725     case 0xfd:
5726         {
5727           /** 1111 1101                 call    %!a0                            */
5728           if (trace)
5729             {
5730               printf ("\033[33m%s\033[0m  %02x\n",
5731                      "/** 1111 1101                     call    %!a0                            */",
5732                      op[0]);
5733             }
5734           SYNTAX("call  %!a0");
5735 #line 426 "rl78-decode.opc"
5736           ID(call); DC(IMMU(2));
5737
5738         }
5739       break;
5740     case 0xfe:
5741         {
5742           /** 1111 1110                 call    $%!a0                           */
5743           if (trace)
5744             {
5745               printf ("\033[33m%s\033[0m  %02x\n",
5746                      "/** 1111 1110                     call    $%!a0                           */",
5747                      op[0]);
5748             }
5749           SYNTAX("call  $%!a0");
5750 #line 429 "rl78-decode.opc"
5751           ID(call); DC(pc+IMMS(2)+3);
5752
5753         }
5754       break;
5755     case 0xff:
5756         {
5757           /** 1111 1111                 brk1                                    */
5758           if (trace)
5759             {
5760               printf ("\033[33m%s\033[0m  %02x\n",
5761                      "/** 1111 1111                     brk1                                    */",
5762                      op[0]);
5763             }
5764           SYNTAX("brk1");
5765 #line 387 "rl78-decode.opc"
5766           ID(break);
5767
5768         }
5769       break;
5770   }
5771 #line 1292 "rl78-decode.opc"
5772
5773   return rl78->n_bytes;
5774 }