op[0]);
             }
           SYNTAX("nop");
-#line 887 "rl78-decode.opc"
+#line 886 "rl78-decode.opc"
           ID(nop);
         
         /*----------------------------------------------------------------------*/
     case 0x07:
         {
           /** 0000 0rw1                        addw    %0, %1                          */
-#line 253 "rl78-decode.opc"
+#line 252 "rl78-decode.opc"
           int rw AU = (op[0] >> 1) & 0x03;
           if (trace)
             {
               printf ("  rw = 0x%x\n", rw);
             }
           SYNTAX("addw %0, %1");
-#line 253 "rl78-decode.opc"
+#line 252 "rl78-decode.opc"
           ID(add); W(); DR(AX); SRW(rw); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("addw %0, %e1%!1");
-#line 244 "rl78-decode.opc"
+#line 243 "rl78-decode.opc"
           ID(add); W(); DR(AX); SM(None, IMMU(2)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("addw %0, #%1");
-#line 250 "rl78-decode.opc"
+#line 249 "rl78-decode.opc"
           ID(add); W(); DR(AX); SC(IMMU(2)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("addw %0, %1");
-#line 256 "rl78-decode.opc"
+#line 255 "rl78-decode.opc"
           ID(add); W(); DR(AX); SM(None, SADDR); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("xch  a, x");
-#line 1210 "rl78-decode.opc"
+#line 1209 "rl78-decode.opc"
           ID(xch); DR(A); SR(X);
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("mov  %0, %e1%1");
-#line 657 "rl78-decode.opc"
+#line 656 "rl78-decode.opc"
           ID(mov); DR(A); SM(B, IMMU(2));
         
         }
                      op[0]);
             }
           SYNTAX("add  %0, #%1");
-#line 207 "rl78-decode.opc"
+#line 206 "rl78-decode.opc"
           ID(add); DM(None, SADDR); SC(IMMU(1)); Fzac;
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("add  %0, %1");
-#line 201 "rl78-decode.opc"
+#line 200 "rl78-decode.opc"
           ID(add); DR(A); SM(None, SADDR); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("add  %0, #%1");
-#line 195 "rl78-decode.opc"
+#line 194 "rl78-decode.opc"
           ID(add); DR(A); SC(IMMU(1)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("add  %0, %e1%1");
-#line 183 "rl78-decode.opc"
+#line 182 "rl78-decode.opc"
           ID(add); DR(A); SM(HL, 0); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("add  %0, %e1%1");
-#line 189 "rl78-decode.opc"
+#line 188 "rl78-decode.opc"
           ID(add); DR(A); SM(HL, IMMU(1)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("add  %0, %e1%!1");
-#line 180 "rl78-decode.opc"
+#line 179 "rl78-decode.opc"
           ID(add); DR(A); SM(None, IMMU(2)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("addw %0, #%1");
-#line 259 "rl78-decode.opc"
+#line 258 "rl78-decode.opc"
           ID(add); W(); DR(SP); SC(IMMU(1)); Fzac;
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("es:");
-#line 172 "rl78-decode.opc"
+#line 171 "rl78-decode.opc"
           DE(); SE();
           op ++;
           pc ++;
     case 0x16:
         {
           /** 0001 0ra0                        movw    %0, %1                          */
-#line 835 "rl78-decode.opc"
+#line 834 "rl78-decode.opc"
           int ra AU = (op[0] >> 1) & 0x03;
           if (trace)
             {
               printf ("  ra = 0x%x\n", ra);
             }
           SYNTAX("movw %0, %1");
-#line 835 "rl78-decode.opc"
+#line 834 "rl78-decode.opc"
           ID(mov); W(); DRW(ra); SR(AX);
         
         }
     case 0x17:
         {
           /** 0001 0ra1                        movw    %0, %1                          */
-#line 832 "rl78-decode.opc"
+#line 831 "rl78-decode.opc"
           int ra AU = (op[0] >> 1) & 0x03;
           if (trace)
             {
               printf ("  ra = 0x%x\n", ra);
             }
           SYNTAX("movw %0, %1");
-#line 832 "rl78-decode.opc"
+#line 831 "rl78-decode.opc"
           ID(mov); W(); DR(AX); SRW(ra);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %e0%0, %1");
-#line 708 "rl78-decode.opc"
+#line 707 "rl78-decode.opc"
           ID(mov); DM(B, IMMU(2)); SR(A);      
         
         }
                      op[0]);
             }
           SYNTAX("mov  %e0%0, #%1");
-#line 705 "rl78-decode.opc"
+#line 704 "rl78-decode.opc"
           ID(mov); DM(B, IMMU(2)); SC(IMMU(1));        
         
         }
                      op[0]);
             }
           SYNTAX("addc %0, #%1");
-#line 239 "rl78-decode.opc"
+#line 238 "rl78-decode.opc"
           ID(addc); DM(None, SADDR); SC(IMMU(1)); Fzac;
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("addc %0, %1");
-#line 236 "rl78-decode.opc"
+#line 235 "rl78-decode.opc"
           ID(addc); DR(A); SM(None, SADDR); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("addc %0, #%1");
-#line 227 "rl78-decode.opc"
+#line 226 "rl78-decode.opc"
           ID(addc); DR(A); SC(IMMU(1)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("addc %0, %e1%1");
-#line 215 "rl78-decode.opc"
+#line 214 "rl78-decode.opc"
           ID(addc); DR(A); SM(HL, 0); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("addc %0, %e1%1");
-#line 224 "rl78-decode.opc"
+#line 223 "rl78-decode.opc"
           ID(addc); DR(A); SM(HL, IMMU(1)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("addc %0, %e1%!1");
-#line 212 "rl78-decode.opc"
+#line 211 "rl78-decode.opc"
           ID(addc); DR(A); SM(None, IMMU(2)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("subw %0, #%1");
-#line 1174 "rl78-decode.opc"
+#line 1173 "rl78-decode.opc"
           ID(sub); W(); DR(SP); SC(IMMU(1)); Fzac;
         
         /*----------------------------------------------------------------------*/
     case 0x27:
         {
           /** 0010 0rw1                        subw    %0, %1                          */
-#line 1168 "rl78-decode.opc"
+#line 1167 "rl78-decode.opc"
           int rw AU = (op[0] >> 1) & 0x03;
           if (trace)
             {
               printf ("  rw = 0x%x\n", rw);
             }
           SYNTAX("subw %0, %1");
-#line 1168 "rl78-decode.opc"
+#line 1167 "rl78-decode.opc"
           ID(sub); W(); DR(AX); SRW(rw); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("subw %0, %e1%!1");
-#line 1159 "rl78-decode.opc"
+#line 1158 "rl78-decode.opc"
           ID(sub); W(); DR(AX); SM(None, IMMU(2)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("subw %0, #%1");
-#line 1165 "rl78-decode.opc"
+#line 1164 "rl78-decode.opc"
           ID(sub); W(); DR(AX); SC(IMMU(2)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("subw %0, %1");
-#line 1171 "rl78-decode.opc"
+#line 1170 "rl78-decode.opc"
           ID(sub); W(); DR(AX); SM(None, SADDR); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("mov  %e0%0, %1");
-#line 720 "rl78-decode.opc"
+#line 719 "rl78-decode.opc"
           ID(mov); DM(C, IMMU(2)); SR(A);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %e1%1");
-#line 663 "rl78-decode.opc"
+#line 662 "rl78-decode.opc"
           ID(mov); DR(A); SM(C, IMMU(2));
         
         }
                      op[0]);
             }
           SYNTAX("sub  %0, #%1");
-#line 1122 "rl78-decode.opc"
+#line 1121 "rl78-decode.opc"
           ID(sub); DM(None, SADDR); SC(IMMU(1)); Fzac;
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("sub  %0, %1");
-#line 1116 "rl78-decode.opc"
+#line 1115 "rl78-decode.opc"
           ID(sub); DR(A); SM(None, SADDR); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("sub  %0, #%1");
-#line 1110 "rl78-decode.opc"
+#line 1109 "rl78-decode.opc"
           ID(sub); DR(A); SC(IMMU(1)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("sub  %0, %e1%1");
-#line 1098 "rl78-decode.opc"
+#line 1097 "rl78-decode.opc"
           ID(sub); DR(A); SM(HL, 0); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("sub  %0, %e1%1");
-#line 1104 "rl78-decode.opc"
+#line 1103 "rl78-decode.opc"
           ID(sub); DR(A); SM(HL, IMMU(1)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("sub  %0, %e1%!1");
-#line 1095 "rl78-decode.opc"
+#line 1094 "rl78-decode.opc"
           ID(sub); DR(A); SM(None, IMMU(2)); Fzac;
         
         }
     case 0x36:
         {
           /** 0011 0rg0                        movw    %0, #%1                         */
-#line 829 "rl78-decode.opc"
+#line 828 "rl78-decode.opc"
           int rg AU = (op[0] >> 1) & 0x03;
           if (trace)
             {
               printf ("  rg = 0x%x\n", rg);
             }
           SYNTAX("movw %0, #%1");
-#line 829 "rl78-decode.opc"
+#line 828 "rl78-decode.opc"
           ID(mov); W(); DRW(rg); SC(IMMU(2));
         
         }
           case 0x00:
               {
                 /** 0011 0001 0bit 0000                btclr   %s1, $%a0                       */
-#line 395 "rl78-decode.opc"
+#line 394 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("btclr  %s1, $%a0");
-#line 395 "rl78-decode.opc"
+#line 394 "rl78-decode.opc"
                 ID(branch_cond_clear); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
               
               /*----------------------------------------------------------------------*/
           case 0x01:
               {
                 /** 0011 0001 0bit 0001                btclr   %1, $%a0                        */
-#line 389 "rl78-decode.opc"
+#line 388 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("btclr  %1, $%a0");
-#line 389 "rl78-decode.opc"
+#line 388 "rl78-decode.opc"
                 ID(branch_cond_clear); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(T);
               
               }
           case 0x02:
               {
                 /** 0011 0001 0bit 0010                bt      %s1, $%a0                       */
-#line 381 "rl78-decode.opc"
+#line 380 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("bt     %s1, $%a0");
-#line 381 "rl78-decode.opc"
+#line 380 "rl78-decode.opc"
                 ID(branch_cond); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
               
               /*----------------------------------------------------------------------*/
           case 0x03:
               {
                 /** 0011 0001 0bit 0011                bt      %1, $%a0                        */
-#line 375 "rl78-decode.opc"
+#line 374 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("bt     %1, $%a0");
-#line 375 "rl78-decode.opc"
+#line 374 "rl78-decode.opc"
                 ID(branch_cond); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(T);
               
               }
           case 0x04:
               {
                 /** 0011 0001 0bit 0100                bf      %s1, $%a0                       */
-#line 342 "rl78-decode.opc"
+#line 341 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("bf     %s1, $%a0");
-#line 342 "rl78-decode.opc"
+#line 341 "rl78-decode.opc"
                 ID(branch_cond); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(F);
               
               /*----------------------------------------------------------------------*/
           case 0x05:
               {
                 /** 0011 0001 0bit 0101                bf      %1, $%a0                        */
-#line 336 "rl78-decode.opc"
+#line 335 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("bf     %1, $%a0");
-#line 336 "rl78-decode.opc"
+#line 335 "rl78-decode.opc"
                 ID(branch_cond); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(F);
               
               }
           case 0x07:
               {
                 /** 0011 0001 0cnt 0111                shl     %0, %1                          */
-#line 1051 "rl78-decode.opc"
+#line 1050 "rl78-decode.opc"
                 int cnt AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  cnt = 0x%x\n", cnt);
                   }
                 SYNTAX("shl    %0, %1");
-#line 1051 "rl78-decode.opc"
+#line 1050 "rl78-decode.opc"
                 ID(shl); DR(C); SC(cnt);
               
               }
           case 0x08:
               {
                 /** 0011 0001 0cnt 1000                shl     %0, %1                          */
-#line 1048 "rl78-decode.opc"
+#line 1047 "rl78-decode.opc"
                 int cnt AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  cnt = 0x%x\n", cnt);
                   }
                 SYNTAX("shl    %0, %1");
-#line 1048 "rl78-decode.opc"
+#line 1047 "rl78-decode.opc"
                 ID(shl); DR(B); SC(cnt);
               
               }
           case 0x09:
               {
                 /** 0011 0001 0cnt 1001                shl     %0, %1                          */
-#line 1045 "rl78-decode.opc"
+#line 1044 "rl78-decode.opc"
                 int cnt AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  cnt = 0x%x\n", cnt);
                   }
                 SYNTAX("shl    %0, %1");
-#line 1045 "rl78-decode.opc"
+#line 1044 "rl78-decode.opc"
                 ID(shl); DR(A); SC(cnt);
               
               }
           case 0x0a:
               {
                 /** 0011 0001 0cnt 1010                shr     %0, %1                          */
-#line 1062 "rl78-decode.opc"
+#line 1061 "rl78-decode.opc"
                 int cnt AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  cnt = 0x%x\n", cnt);
                   }
                 SYNTAX("shr    %0, %1");
-#line 1062 "rl78-decode.opc"
+#line 1061 "rl78-decode.opc"
                 ID(shr); DR(A); SC(cnt);
               
               }
           case 0x0b:
               {
                 /** 0011 0001 0cnt 1011                sar     %0, %1                          */
-#line 1009 "rl78-decode.opc"
+#line 1008 "rl78-decode.opc"
                 int cnt AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  cnt = 0x%x\n", cnt);
                   }
                 SYNTAX("sar    %0, %1");
-#line 1009 "rl78-decode.opc"
+#line 1008 "rl78-decode.opc"
                 ID(sar); DR(A); SC(cnt);
               
               }
           case 0x8c:
               {
                 /** 0011 0001 wcnt 1100                shlw    %0, %1                          */
-#line 1057 "rl78-decode.opc"
+#line 1056 "rl78-decode.opc"
                 int wcnt AU = (op[1] >> 4) & 0x0f;
                 if (trace)
                   {
                     printf ("  wcnt = 0x%x\n", wcnt);
                   }
                 SYNTAX("shlw   %0, %1");
-#line 1057 "rl78-decode.opc"
+#line 1056 "rl78-decode.opc"
                 ID(shl); W(); DR(BC); SC(wcnt);
               
               /*----------------------------------------------------------------------*/
           case 0x8d:
               {
                 /** 0011 0001 wcnt 1101                shlw    %0, %1                          */
-#line 1054 "rl78-decode.opc"
+#line 1053 "rl78-decode.opc"
                 int wcnt AU = (op[1] >> 4) & 0x0f;
                 if (trace)
                   {
                     printf ("  wcnt = 0x%x\n", wcnt);
                   }
                 SYNTAX("shlw   %0, %1");
-#line 1054 "rl78-decode.opc"
+#line 1053 "rl78-decode.opc"
                 ID(shl); W(); DR(AX); SC(wcnt);
               
               }
           case 0x8e:
               {
                 /** 0011 0001 wcnt 1110                shrw    %0, %1                          */
-#line 1065 "rl78-decode.opc"
+#line 1064 "rl78-decode.opc"
                 int wcnt AU = (op[1] >> 4) & 0x0f;
                 if (trace)
                   {
                     printf ("  wcnt = 0x%x\n", wcnt);
                   }
                 SYNTAX("shrw   %0, %1");
-#line 1065 "rl78-decode.opc"
+#line 1064 "rl78-decode.opc"
                 ID(shr); W(); DR(AX); SC(wcnt);
               
               /*----------------------------------------------------------------------*/
           case 0x8f:
               {
                 /** 0011 0001 wcnt 1111                sarw    %0, %1                          */
-#line 1012 "rl78-decode.opc"
+#line 1011 "rl78-decode.opc"
                 int wcnt AU = (op[1] >> 4) & 0x0f;
                 if (trace)
                   {
                     printf ("  wcnt = 0x%x\n", wcnt);
                   }
                 SYNTAX("sarw   %0, %1");
-#line 1012 "rl78-decode.opc"
+#line 1011 "rl78-decode.opc"
                 ID(sar); W(); DR(AX); SC(wcnt);
               
               /*----------------------------------------------------------------------*/
           case 0x80:
               {
                 /** 0011 0001 1bit 0000                btclr   %s1, $%a0                       */
-#line 392 "rl78-decode.opc"
+#line 391 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("btclr  %s1, $%a0");
-#line 392 "rl78-decode.opc"
+#line 391 "rl78-decode.opc"
                 ID(branch_cond_clear); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
               
               }
           case 0x81:
               {
                 /** 0011 0001 1bit 0001                btclr   %e1%1, $%a0                     */
-#line 386 "rl78-decode.opc"
+#line 385 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("btclr  %e1%1, $%a0");
-#line 386 "rl78-decode.opc"
+#line 385 "rl78-decode.opc"
                 ID(branch_cond_clear); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(T);
               
               }
           case 0x82:
               {
                 /** 0011 0001 1bit 0010                bt      %s1, $%a0                       */
-#line 378 "rl78-decode.opc"
+#line 377 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("bt     %s1, $%a0");
-#line 378 "rl78-decode.opc"
+#line 377 "rl78-decode.opc"
                 ID(branch_cond); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
               
               }
           case 0x83:
               {
                 /** 0011 0001 1bit 0011                bt      %e1%1, $%a0                     */
-#line 372 "rl78-decode.opc"
+#line 371 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("bt     %e1%1, $%a0");
-#line 372 "rl78-decode.opc"
+#line 371 "rl78-decode.opc"
                 ID(branch_cond); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(T);
               
               }
           case 0x84:
               {
                 /** 0011 0001 1bit 0100                bf      %s1, $%a0                       */
-#line 339 "rl78-decode.opc"
+#line 338 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("bf     %s1, $%a0");
-#line 339 "rl78-decode.opc"
+#line 338 "rl78-decode.opc"
                 ID(branch_cond); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(F);
               
               }
           case 0x85:
               {
                 /** 0011 0001 1bit 0101                bf      %e1%1, $%a0                     */
-#line 333 "rl78-decode.opc"
+#line 332 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("bf     %e1%1, $%a0");
-#line 333 "rl78-decode.opc"
+#line 332 "rl78-decode.opc"
                 ID(branch_cond); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(F);
               
               }
     case 0x37:
         {
           /** 0011 0ra1                        xchw    %0, %1                          */
-#line 1215 "rl78-decode.opc"
+#line 1214 "rl78-decode.opc"
           int ra AU = (op[0] >> 1) & 0x03;
           if (trace)
             {
               printf ("  ra = 0x%x\n", ra);
             }
           SYNTAX("xchw %0, %1");
-#line 1215 "rl78-decode.opc"
+#line 1214 "rl78-decode.opc"
           ID(xch); W(); DR(AX); SRW(ra);
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("mov  %e0%0, #%1");
-#line 717 "rl78-decode.opc"
+#line 716 "rl78-decode.opc"
           ID(mov); DM(C, IMMU(2)); SC(IMMU(1));        
         
         }
                      op[0]);
             }
           SYNTAX("mov  %e0%0, #%1");
-#line 711 "rl78-decode.opc"
+#line 710 "rl78-decode.opc"
           ID(mov); DM(BC, IMMU(2)); SC(IMMU(1));       
         
         }
                      op[0]);
             }
           SYNTAX("subc %0, #%1");
-#line 1154 "rl78-decode.opc"
+#line 1153 "rl78-decode.opc"
           ID(subc); DM(None, SADDR); SC(IMMU(1)); Fzac;
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("subc %0, %1");
-#line 1151 "rl78-decode.opc"
+#line 1150 "rl78-decode.opc"
           ID(subc); DR(A); SM(None, SADDR); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("subc %0, #%1");
-#line 1142 "rl78-decode.opc"
+#line 1141 "rl78-decode.opc"
           ID(subc); DR(A); SC(IMMU(1)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("subc %0, %e1%1");
-#line 1130 "rl78-decode.opc"
+#line 1129 "rl78-decode.opc"
           ID(subc); DR(A); SM(HL, 0); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("subc %0, %e1%1");
-#line 1139 "rl78-decode.opc"
+#line 1138 "rl78-decode.opc"
           ID(subc); DR(A); SM(HL, IMMU(1)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("subc %0, %e1%!1");
-#line 1127 "rl78-decode.opc"
+#line 1126 "rl78-decode.opc"
           ID(subc); DR(A); SM(None, IMMU(2)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("cmp  %e0%!0, #%1");
-#line 459 "rl78-decode.opc"
+#line 458 "rl78-decode.opc"
           ID(cmp); DM(None, IMMU(2)); SC(IMMU(1)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, #%1");
-#line 696 "rl78-decode.opc"
+#line 695 "rl78-decode.opc"
           ID(mov); DR(ES); SC(IMMU(1));        
         
         }
                      op[0]);
             }
           SYNTAX("cmpw %0, %e1%!1");
-#line 510 "rl78-decode.opc"
+#line 509 "rl78-decode.opc"
           ID(cmp); W(); DR(AX); SM(None, IMMU(2)); Fzac;
         
         }
     case 0x47:
         {
           /** 0100 0ra1                        cmpw    %0, %1                          */
-#line 519 "rl78-decode.opc"
+#line 518 "rl78-decode.opc"
           int ra AU = (op[0] >> 1) & 0x03;
           if (trace)
             {
               printf ("  ra = 0x%x\n", ra);
             }
           SYNTAX("cmpw %0, %1");
-#line 519 "rl78-decode.opc"
+#line 518 "rl78-decode.opc"
           ID(cmp); W(); DR(AX); SRW(ra); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("cmpw %0, #%1");
-#line 516 "rl78-decode.opc"
+#line 515 "rl78-decode.opc"
           ID(cmp); W(); DR(AX); SC(IMMU(2)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("cmpw %0, %1");
-#line 522 "rl78-decode.opc"
+#line 521 "rl78-decode.opc"
           ID(cmp); W(); DR(AX); SM(None, SADDR); Fzac;
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("mov  %e0%0, %1");
-#line 714 "rl78-decode.opc"
+#line 713 "rl78-decode.opc"
           ID(mov); DM(BC, IMMU(2)); SR(A);     
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %e1%1");
-#line 660 "rl78-decode.opc"
+#line 659 "rl78-decode.opc"
           ID(mov); DR(A); SM(BC, IMMU(2));
         
         }
                      op[0]);
             }
           SYNTAX("cmp  %0, #%1");
-#line 462 "rl78-decode.opc"
+#line 461 "rl78-decode.opc"
           ID(cmp); DM(None, SADDR); SC(IMMU(1)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("cmp  %0, %1");
-#line 489 "rl78-decode.opc"
+#line 488 "rl78-decode.opc"
           ID(cmp); DR(A); SM(None, SADDR); Fzac;
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("cmp  %0, #%1");
-#line 480 "rl78-decode.opc"
+#line 479 "rl78-decode.opc"
           ID(cmp); DR(A); SC(IMMU(1)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("cmp  %0, %e1%1");
-#line 468 "rl78-decode.opc"
+#line 467 "rl78-decode.opc"
           ID(cmp); DR(A); SM(HL, 0); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("cmp  %0, %e1%1");
-#line 477 "rl78-decode.opc"
+#line 476 "rl78-decode.opc"
           ID(cmp); DR(A); SM(HL, IMMU(1)); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("cmp  %0, %e1%!1");
-#line 465 "rl78-decode.opc"
+#line 464 "rl78-decode.opc"
           ID(cmp); DR(A); SM(None, IMMU(2)); Fzac;
         
         }
     case 0x57:
         {
           /** 0101 0reg                        mov     %0, #%1                         */
-#line 648 "rl78-decode.opc"
+#line 647 "rl78-decode.opc"
           int reg AU = op[0] & 0x07;
           if (trace)
             {
               printf ("  reg = 0x%x\n", reg);
             }
           SYNTAX("mov  %0, #%1");
-#line 648 "rl78-decode.opc"
+#line 647 "rl78-decode.opc"
           ID(mov); DRB(reg); SC(IMMU(1));
         
         }
                      op[0]);
             }
           SYNTAX("movw %e0%0, %1");
-#line 847 "rl78-decode.opc"
+#line 846 "rl78-decode.opc"
           ID(mov); W(); DM(B, IMMU(2)); SR(AX);
         
         }
                      op[0]);
             }
           SYNTAX("movw %0, %e1%1");
-#line 838 "rl78-decode.opc"
+#line 837 "rl78-decode.opc"
           ID(mov); W(); DR(AX); SM(B, IMMU(2));
         
         }
                      op[0]);
             }
           SYNTAX("and  %0, #%1");
-#line 291 "rl78-decode.opc"
+#line 290 "rl78-decode.opc"
           ID(and); DM(None, SADDR); SC(IMMU(1)); Fz;
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("and  %0, %1");
-#line 288 "rl78-decode.opc"
+#line 287 "rl78-decode.opc"
           ID(and); DR(A); SM(None, SADDR); Fz;
         
         }
                      op[0]);
             }
           SYNTAX("and  %0, #%1");
-#line 279 "rl78-decode.opc"
+#line 278 "rl78-decode.opc"
           ID(and); DR(A); SC(IMMU(1)); Fz;
         
         }
                      op[0]);
             }
           SYNTAX("and  %0, %e1%1");
-#line 267 "rl78-decode.opc"
+#line 266 "rl78-decode.opc"
           ID(and); DR(A); SM(HL, 0); Fz;
         
         }
                      op[0]);
             }
           SYNTAX("and  %0, %e1%1");
-#line 273 "rl78-decode.opc"
+#line 272 "rl78-decode.opc"
           ID(and); DR(A); SM(HL, IMMU(1)); Fz;
         
         }
                      op[0]);
             }
           SYNTAX("and  %0, %e1%!1");
-#line 264 "rl78-decode.opc"
+#line 263 "rl78-decode.opc"
           ID(and); DR(A); SM(None, IMMU(2)); Fz;
         
         }
     case 0x67:
         {
           /** 0110 0rba                        mov     %0, %1                          */
-#line 651 "rl78-decode.opc"
+#line 650 "rl78-decode.opc"
           int rba AU = op[0] & 0x07;
           if (trace)
             {
               printf ("  rba = 0x%x\n", rba);
             }
           SYNTAX("mov  %0, %1");
-#line 651 "rl78-decode.opc"
+#line 650 "rl78-decode.opc"
           ID(mov); DR(A); SRB(rba);
         
         }
           case 0x07:
               {
                 /** 0110 0001 0000 0reg                add     %0, %1                          */
-#line 204 "rl78-decode.opc"
+#line 203 "rl78-decode.opc"
                 int reg AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  reg = 0x%x\n", reg);
                   }
                 SYNTAX("add    %0, %1");
-#line 204 "rl78-decode.opc"
+#line 203 "rl78-decode.opc"
                 ID(add); DRB(reg); SR(A); Fzac;
               
               }
           case 0x0f:
               {
                 /** 0110 0001 0000 1rba                add     %0, %1                          */
-#line 198 "rl78-decode.opc"
+#line 197 "rl78-decode.opc"
                 int rba AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  rba = 0x%x\n", rba);
                   }
                 SYNTAX("add    %0, %1");
-#line 198 "rl78-decode.opc"
+#line 197 "rl78-decode.opc"
                 ID(add); DR(A); SRB(rba); Fzac;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("addw   %0, %e1%1");
-#line 247 "rl78-decode.opc"
+#line 246 "rl78-decode.opc"
                 ID(add); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
               
               }
           case 0x17:
               {
                 /** 0110 0001 0001 0reg                addc    %0, %1                          */
-#line 233 "rl78-decode.opc"
+#line 232 "rl78-decode.opc"
                 int reg AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  reg = 0x%x\n", reg);
                   }
                 SYNTAX("addc   %0, %1");
-#line 233 "rl78-decode.opc"
+#line 232 "rl78-decode.opc"
                 ID(addc); DRB(reg); SR(A); Fzac;
               
               }
           case 0x1f:
               {
                 /** 0110 0001 0001 1rba                addc    %0, %1                          */
-#line 230 "rl78-decode.opc"
+#line 229 "rl78-decode.opc"
                 int rba AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  rba = 0x%x\n", rba);
                   }
                 SYNTAX("addc   %0, %1");
-#line 230 "rl78-decode.opc"
+#line 229 "rl78-decode.opc"
                 ID(addc); DR(A); SRB(rba); Fzac;
               
               }
           case 0x27:
               {
                 /** 0110 0001 0010 0reg                sub     %0, %1                          */
-#line 1119 "rl78-decode.opc"
+#line 1118 "rl78-decode.opc"
                 int reg AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  reg = 0x%x\n", reg);
                   }
                 SYNTAX("sub    %0, %1");
-#line 1119 "rl78-decode.opc"
+#line 1118 "rl78-decode.opc"
                 ID(sub); DRB(reg); SR(A); Fzac;
               
               }
           case 0x2f:
               {
                 /** 0110 0001 0010 1rba                sub     %0, %1                          */
-#line 1113 "rl78-decode.opc"
+#line 1112 "rl78-decode.opc"
                 int rba AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  rba = 0x%x\n", rba);
                   }
                 SYNTAX("sub    %0, %1");
-#line 1113 "rl78-decode.opc"
+#line 1112 "rl78-decode.opc"
                 ID(sub); DR(A); SRB(rba); Fzac;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("subw   %0, %e1%1");
-#line 1162 "rl78-decode.opc"
+#line 1161 "rl78-decode.opc"
                 ID(sub); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
               
               }
           case 0x37:
               {
                 /** 0110 0001 0011 0reg                subc    %0, %1                          */
-#line 1148 "rl78-decode.opc"
+#line 1147 "rl78-decode.opc"
                 int reg AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  reg = 0x%x\n", reg);
                   }
                 SYNTAX("subc   %0, %1");
-#line 1148 "rl78-decode.opc"
+#line 1147 "rl78-decode.opc"
                 ID(subc); DRB(reg); SR(A); Fzac;
               
               }
           case 0x3f:
               {
                 /** 0110 0001 0011 1rba                subc    %0, %1                          */
-#line 1145 "rl78-decode.opc"
+#line 1144 "rl78-decode.opc"
                 int rba AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  rba = 0x%x\n", rba);
                   }
                 SYNTAX("subc   %0, %1");
-#line 1145 "rl78-decode.opc"
+#line 1144 "rl78-decode.opc"
                 ID(subc); DR(A); SRB(rba); Fzac;
               
               }
           case 0x47:
               {
                 /** 0110 0001 0100 0reg                cmp     %0, %1                          */
-#line 486 "rl78-decode.opc"
+#line 485 "rl78-decode.opc"
                 int reg AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  reg = 0x%x\n", reg);
                   }
                 SYNTAX("cmp    %0, %1");
-#line 486 "rl78-decode.opc"
+#line 485 "rl78-decode.opc"
                 ID(cmp); DRB(reg); SR(A); Fzac;
               
               }
           case 0x4f:
               {
                 /** 0110 0001 0100 1rba                cmp     %0, %1                          */
-#line 483 "rl78-decode.opc"
+#line 482 "rl78-decode.opc"
                 int rba AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  rba = 0x%x\n", rba);
                   }
                 SYNTAX("cmp    %0, %1");
-#line 483 "rl78-decode.opc"
+#line 482 "rl78-decode.opc"
                 ID(cmp); DR(A); SRB(rba); Fzac;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("cmpw   %0, %e1%1");
-#line 513 "rl78-decode.opc"
+#line 512 "rl78-decode.opc"
                 ID(cmp); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
               
               }
           case 0x57:
               {
                 /** 0110 0001 0101 0reg                and     %0, %1                          */
-#line 285 "rl78-decode.opc"
+#line 284 "rl78-decode.opc"
                 int reg AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  reg = 0x%x\n", reg);
                   }
                 SYNTAX("and    %0, %1");
-#line 285 "rl78-decode.opc"
+#line 284 "rl78-decode.opc"
                 ID(and); DRB(reg); SR(A); Fz;
               
               }
           case 0x5f:
               {
                 /** 0110 0001 0101 1rba                and     %0, %1                          */
-#line 282 "rl78-decode.opc"
+#line 281 "rl78-decode.opc"
                 int rba AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  rba = 0x%x\n", rba);
                   }
                 SYNTAX("and    %0, %1");
-#line 282 "rl78-decode.opc"
+#line 281 "rl78-decode.opc"
                 ID(and); DR(A); SRB(rba); Fz;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("inc    %e0%0");
-#line 563 "rl78-decode.opc"
+#line 562 "rl78-decode.opc"
                 ID(add); DM(HL, IMMU(1)); SC(1); Fza;
               
               }
           case 0x67:
               {
                 /** 0110 0001 0110 0reg                or      %0, %1                          */
-#line 937 "rl78-decode.opc"
+#line 936 "rl78-decode.opc"
                 int reg AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  reg = 0x%x\n", reg);
                   }
                 SYNTAX("or     %0, %1");
-#line 937 "rl78-decode.opc"
+#line 936 "rl78-decode.opc"
                 ID(or); DRB(reg); SR(A); Fz;
               
               }
           case 0x6f:
               {
                 /** 0110 0001 0110 1rba                or      %0, %1                          */
-#line 934 "rl78-decode.opc"
+#line 933 "rl78-decode.opc"
                 int rba AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  rba = 0x%x\n", rba);
                   }
                 SYNTAX("or     %0, %1");
-#line 934 "rl78-decode.opc"
+#line 933 "rl78-decode.opc"
                 ID(or); DR(A); SRB(rba); Fz;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("dec    %e0%0");
-#line 530 "rl78-decode.opc"
+#line 529 "rl78-decode.opc"
                 ID(sub); DM(HL, IMMU(1)); SC(1); Fza;
               
               }
           case 0x77:
               {
                 /** 0110 0001 0111 0reg                xor     %0, %1                          */
-#line 1241 "rl78-decode.opc"
+#line 1240 "rl78-decode.opc"
                 int reg AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  reg = 0x%x\n", reg);
                   }
                 SYNTAX("xor    %0, %1");
-#line 1241 "rl78-decode.opc"
+#line 1240 "rl78-decode.opc"
                 ID(xor); DRB(reg); SR(A); Fz;
               
               }
           case 0x7f:
               {
                 /** 0110 0001 0111 1rba                xor     %0, %1                          */
-#line 1238 "rl78-decode.opc"
+#line 1237 "rl78-decode.opc"
                 int rba AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  rba = 0x%x\n", rba);
                   }
                 SYNTAX("xor    %0, %1");
-#line 1238 "rl78-decode.opc"
+#line 1237 "rl78-decode.opc"
                 ID(xor); DR(A); SRB(rba); Fz;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("incw   %e0%0");
-#line 577 "rl78-decode.opc"
+#line 576 "rl78-decode.opc"
                 ID(add); W(); DM(HL, IMMU(1)); SC(1);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("add    %0, %e1%1");
-#line 186 "rl78-decode.opc"
+#line 185 "rl78-decode.opc"
                 ID(add); DR(A); SM2(HL, B, 0); Fzac;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("add    %0, %e1%1");
-#line 192 "rl78-decode.opc"
+#line 191 "rl78-decode.opc"
                 ID(add); DR(A); SM2(HL, C, 0); Fzac;
               
               }
           case 0xf7:
               {
                 /** 0110 0001 1nnn 01mm                callt   [%x0]                           */
-#line 412 "rl78-decode.opc"
+#line 411 "rl78-decode.opc"
                 int nnn AU = (op[1] >> 4) & 0x07;
-#line 412 "rl78-decode.opc"
+#line 411 "rl78-decode.opc"
                 int mm AU = op[1] & 0x03;
                 if (trace)
                   {
                     printf ("  mm = 0x%x\n", mm);
                   }
                 SYNTAX("callt  [%x0]");
-#line 412 "rl78-decode.opc"
+#line 411 "rl78-decode.opc"
                 ID(call); DM(None, 0x80 + mm*16 + nnn*2);
               
               /*----------------------------------------------------------------------*/
           case 0x8f:
               {
                 /** 0110 0001 1000 1reg                xch     %0, %1                          */
-#line 1200 "rl78-decode.opc"
+#line 1199 "rl78-decode.opc"
                 int reg AU = op[1] & 0x07;
                 if (trace)
                   {
                     printf ("  reg = 0x%x\n", reg);
                   }
                 SYNTAX("xch    %0, %1");
-#line 1200 "rl78-decode.opc"
+#line 1199 "rl78-decode.opc"
                 /* Note: DECW uses reg == X, so this must follow DECW */
                 ID(xch); DR(A); SRB(reg);
               
                            op[0], op[1]);
                   }
                 SYNTAX("decw   %e0%0");
-#line 544 "rl78-decode.opc"
+#line 543 "rl78-decode.opc"
                 ID(sub); W(); DM(HL, IMMU(1)); SC(1);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("addc   %0, %e1%1");
-#line 218 "rl78-decode.opc"
+#line 217 "rl78-decode.opc"
                 ID(addc); DR(A); SM2(HL, B, 0); Fzac;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("addc   %0, %e1%1");
-#line 221 "rl78-decode.opc"
+#line 220 "rl78-decode.opc"
                 ID(addc); DR(A); SM2(HL, C, 0); Fzac;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("sub    %0, %e1%1");
-#line 1101 "rl78-decode.opc"
+#line 1100 "rl78-decode.opc"
                 ID(sub); DR(A); SM2(HL, B, 0); Fzac;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("sub    %0, %e1%1");
-#line 1107 "rl78-decode.opc"
+#line 1106 "rl78-decode.opc"
                 ID(sub); DR(A); SM2(HL, C, 0); Fzac;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("xch    %0, %1");
-#line 1204 "rl78-decode.opc"
+#line 1203 "rl78-decode.opc"
                 ID(xch); DR(A); SM(None, SADDR);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("xch    %0, %e1%1");
-#line 1197 "rl78-decode.opc"
+#line 1196 "rl78-decode.opc"
                 ID(xch); DR(A); SM2(HL, C, 0);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("xch    %0, %e1%!1");
-#line 1179 "rl78-decode.opc"
+#line 1178 "rl78-decode.opc"
                 ID(xch); DR(A); SM(None, IMMU(2));
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("xch    %0, %1");
-#line 1207 "rl78-decode.opc"
+#line 1206 "rl78-decode.opc"
                 ID(xch); DR(A); SM(None, SFR);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("xch    %0, %e1%1");
-#line 1188 "rl78-decode.opc"
+#line 1187 "rl78-decode.opc"
                 ID(xch); DR(A); SM(HL, 0);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("xch    %0, %e1%1");
-#line 1194 "rl78-decode.opc"
+#line 1193 "rl78-decode.opc"
                 ID(xch); DR(A); SM(HL, IMMU(1));
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("xch    %0, %e1%1");
-#line 1182 "rl78-decode.opc"
+#line 1181 "rl78-decode.opc"
                 ID(xch); DR(A); SM(DE, 0);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("xch    %0, %e1%1");
-#line 1185 "rl78-decode.opc"
+#line 1184 "rl78-decode.opc"
                 ID(xch); DR(A); SM(DE, IMMU(1));
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("subc   %0, %e1%1");
-#line 1133 "rl78-decode.opc"
+#line 1132 "rl78-decode.opc"
                 ID(subc); DR(A); SM2(HL, B, 0); Fzac;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("subc   %0, %e1%1");
-#line 1136 "rl78-decode.opc"
+#line 1135 "rl78-decode.opc"
                 ID(subc); DR(A); SM2(HL, C, 0); Fzac;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("mov    %0, %1");
-#line 702 "rl78-decode.opc"
+#line 701 "rl78-decode.opc"
                 ID(mov); DR(ES); SM(None, SADDR);      
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("xch    %0, %e1%1");
-#line 1191 "rl78-decode.opc"
+#line 1190 "rl78-decode.opc"
                 ID(xch); DR(A); SM2(HL, B, 0);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("cmp    %0, %e1%1");
-#line 471 "rl78-decode.opc"
+#line 470 "rl78-decode.opc"
                 ID(cmp); DR(A); SM2(HL, B, 0); Fzac;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("cmp    %0, %e1%1");
-#line 474 "rl78-decode.opc"
+#line 473 "rl78-decode.opc"
                 ID(cmp); DR(A); SM2(HL, C, 0); Fzac;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("bh     $%a0");
-#line 319 "rl78-decode.opc"
+#line 318 "rl78-decode.opc"
                 ID(branch_cond); DC(pc+IMMS(1)+3); SR(None); COND(H);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("sk%c1");
-#line 1070 "rl78-decode.opc"
+#line 1069 "rl78-decode.opc"
                 ID(skip); COND(C);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("mov    %0, %e1%1");
-#line 639 "rl78-decode.opc"
+#line 638 "rl78-decode.opc"
                 ID(mov); DR(A); SM2(HL, B, 0);
               
               }
           case 0xfa:
               {
                 /** 0110 0001 11rg 1010                call    %0                              */
-#line 409 "rl78-decode.opc"
+#line 408 "rl78-decode.opc"
                 int rg AU = (op[1] >> 4) & 0x03;
                 if (trace)
                   {
                     printf ("  rg = 0x%x\n", rg);
                   }
                 SYNTAX("call   %0");
-#line 409 "rl78-decode.opc"
+#line 408 "rl78-decode.opc"
                 ID(call); DRW(rg);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("br     ax");
-#line 359 "rl78-decode.opc"
+#line 358 "rl78-decode.opc"
                 ID(branch); DR(AX);
               
               /*----------------------------------------------------------------------*/
                            op[0], op[1]);
                   }
                 SYNTAX("brk");
-#line 367 "rl78-decode.opc"
+#line 366 "rl78-decode.opc"
                 ID(break);
               
               /*----------------------------------------------------------------------*/
                            op[0], op[1]);
                   }
                 SYNTAX("pop    %s0");
-#line 965 "rl78-decode.opc"
+#line 964 "rl78-decode.opc"
                 ID(mov); W(); DR(PSW); SPOP();
               
               /*----------------------------------------------------------------------*/
                            op[0], op[1]);
                   }
                 SYNTAX("movs   %e0%0, %1");
-#line 787 "rl78-decode.opc"
+#line 786 "rl78-decode.opc"
                 ID(mov); DM(HL, IMMU(1)); SR(X); Fzc;
               
               /*----------------------------------------------------------------------*/
           case 0xff:
               {
                 /** 0110 0001 11rb 1111                sel     rb%1                            */
-#line 1017 "rl78-decode.opc"
+#line 1016 "rl78-decode.opc"
                 int rb AU = (op[1] >> 4) & 0x03;
                 if (trace)
                   {
                     printf ("  rb = 0x%x\n", rb);
                   }
                 SYNTAX("sel    rb%1");
-#line 1017 "rl78-decode.opc"
+#line 1016 "rl78-decode.opc"
                 ID(sel); SC(rb);
               
               /*----------------------------------------------------------------------*/
                            op[0], op[1]);
                   }
                 SYNTAX("and    %0, %e1%1");
-#line 270 "rl78-decode.opc"
+#line 269 "rl78-decode.opc"
                 ID(and); DR(A); SM2(HL, B, 0); Fz;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("and    %0, %e1%1");
-#line 276 "rl78-decode.opc"
+#line 275 "rl78-decode.opc"
                 ID(and); DR(A); SM2(HL, C, 0); Fz;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("bnh    $%a0");
-#line 322 "rl78-decode.opc"
+#line 321 "rl78-decode.opc"
                 ID(branch_cond); DC(pc+IMMS(1)+3); SR(None); COND(NH);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("sk%c1");
-#line 1076 "rl78-decode.opc"
+#line 1075 "rl78-decode.opc"
                 ID(skip); COND(NC);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("mov    %e0%0, %1");
-#line 606 "rl78-decode.opc"
+#line 605 "rl78-decode.opc"
                 ID(mov); DM2(HL, B, 0); SR(A);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("ror    %0, %1");
-#line 998 "rl78-decode.opc"
+#line 997 "rl78-decode.opc"
                 ID(ror); DR(A); SC(1);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("rolc   %0, %1");
-#line 992 "rl78-decode.opc"
+#line 991 "rl78-decode.opc"
                 ID(rolc); DR(A); SC(1);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("push   %s1");
-#line 973 "rl78-decode.opc"
+#line 972 "rl78-decode.opc"
                 ID(mov); W(); DPUSH(); SR(PSW);
               
               /*----------------------------------------------------------------------*/
                            op[0], op[1]);
                   }
                 SYNTAX("cmps   %0, %e1%1");
-#line 505 "rl78-decode.opc"
+#line 504 "rl78-decode.opc"
                 ID(cmp); DR(X); SM(HL, IMMU(1)); Fzac;
               
               /*----------------------------------------------------------------------*/
                            op[0], op[1]);
                   }
                 SYNTAX("or     %0, %e1%1");
-#line 922 "rl78-decode.opc"
+#line 921 "rl78-decode.opc"
                 ID(or); DR(A); SM2(HL, B, 0); Fz;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("or     %0, %e1%1");
-#line 928 "rl78-decode.opc"
+#line 927 "rl78-decode.opc"
                 ID(or); DR(A); SM2(HL, C, 0); Fz;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("sk%c1");
-#line 1073 "rl78-decode.opc"
+#line 1072 "rl78-decode.opc"
                 ID(skip); COND(H);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("sk%c1");
-#line 1085 "rl78-decode.opc"
+#line 1084 "rl78-decode.opc"
                 ID(skip); COND(Z);
               
               /*----------------------------------------------------------------------*/
                            op[0], op[1]);
                   }
                 SYNTAX("mov    %0, %e1%1");
-#line 642 "rl78-decode.opc"
+#line 641 "rl78-decode.opc"
                 ID(mov); DR(A); SM2(HL, C, 0);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("rol    %0, %1");
-#line 989 "rl78-decode.opc"
+#line 988 "rl78-decode.opc"
                 ID(rol); DR(A); SC(1);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("retb");
-#line 984 "rl78-decode.opc"
+#line 983 "rl78-decode.opc"
                 ID(reti);
               
               /*----------------------------------------------------------------------*/
                            op[0], op[1]);
                   }
                 SYNTAX("halt");
-#line 555 "rl78-decode.opc"
+#line 554 "rl78-decode.opc"
                 ID(halt);
               
               /*----------------------------------------------------------------------*/
           case 0xfe:
               {
                 /** 0110 0001 111r 1110                rolwc   %0, %1                          */
-#line 995 "rl78-decode.opc"
+#line 994 "rl78-decode.opc"
                 int r AU = (op[1] >> 4) & 0x01;
                 if (trace)
                   {
                     printf ("  r = 0x%x\n", r);
                   }
                 SYNTAX("rolwc  %0, %1");
-#line 995 "rl78-decode.opc"
+#line 994 "rl78-decode.opc"
                 ID(rolc); W(); DRW(r); SC(1);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("xor    %0, %e1%1");
-#line 1226 "rl78-decode.opc"
+#line 1225 "rl78-decode.opc"
                 ID(xor); DR(A); SM2(HL, B, 0); Fz;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("xor    %0, %e1%1");
-#line 1232 "rl78-decode.opc"
+#line 1231 "rl78-decode.opc"
                 ID(xor); DR(A); SM2(HL, C, 0); Fz;
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("sk%c1");
-#line 1079 "rl78-decode.opc"
+#line 1078 "rl78-decode.opc"
                 ID(skip); COND(NH);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("sk%c1");
-#line 1082 "rl78-decode.opc"
+#line 1081 "rl78-decode.opc"
                 ID(skip); COND(NZ);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("mov    %e0%0, %1");
-#line 615 "rl78-decode.opc"
+#line 614 "rl78-decode.opc"
                 ID(mov); DM2(HL, C, 0); SR(A);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("rorc   %0, %1");
-#line 1001 "rl78-decode.opc"
+#line 1000 "rl78-decode.opc"
                 ID(rorc); DR(A); SC(1);
               
               /*----------------------------------------------------------------------*/
                            op[0], op[1]);
                   }
                 SYNTAX("reti");
-#line 981 "rl78-decode.opc"
+#line 980 "rl78-decode.opc"
                 ID(reti);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("stop");
-#line 1090 "rl78-decode.opc"
+#line 1089 "rl78-decode.opc"
                 ID(stop);
               
               /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("movw %e0%0, %1");
-#line 850 "rl78-decode.opc"
+#line 849 "rl78-decode.opc"
           ID(mov); W(); DM(C, IMMU(2)); SR(AX);
         
         }
                      op[0]);
             }
           SYNTAX("movw %0, %e1%1");
-#line 841 "rl78-decode.opc"
+#line 840 "rl78-decode.opc"
           ID(mov); W(); DR(AX); SM(C, IMMU(2));
         
         }
                      op[0]);
             }
           SYNTAX("or   %0, #%1");
-#line 943 "rl78-decode.opc"
+#line 942 "rl78-decode.opc"
           ID(or); DM(None, SADDR); SC(IMMU(1)); Fz;
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("or   %0, %1");
-#line 940 "rl78-decode.opc"
+#line 939 "rl78-decode.opc"
           ID(or); DR(A); SM(None, SADDR); Fz;
         
         }
                      op[0]);
             }
           SYNTAX("or   %0, #%1");
-#line 931 "rl78-decode.opc"
+#line 930 "rl78-decode.opc"
           ID(or); DR(A); SC(IMMU(1)); Fz;
         
         }
                      op[0]);
             }
           SYNTAX("or   %0, %e1%1");
-#line 919 "rl78-decode.opc"
+#line 918 "rl78-decode.opc"
           ID(or); DR(A); SM(HL, 0); Fz;
         
         }
                      op[0]);
             }
           SYNTAX("or   %0, %e1%1");
-#line 925 "rl78-decode.opc"
+#line 924 "rl78-decode.opc"
           ID(or); DR(A); SM(HL, IMMU(1)); Fz;
         
         }
                      op[0]);
             }
           SYNTAX("or   %0, %e1%!1");
-#line 916 "rl78-decode.opc"
+#line 915 "rl78-decode.opc"
           ID(or); DR(A); SM(None, IMMU(2)); Fz;
         
         }
     case 0x77:
         {
           /** 0111 0rba                        mov     %0, %1                          */
-#line 675 "rl78-decode.opc"
+#line 674 "rl78-decode.opc"
           int rba AU = op[0] & 0x07;
           if (trace)
             {
               printf ("  rba = 0x%x\n", rba);
             }
           SYNTAX("mov  %0, %1");
-#line 675 "rl78-decode.opc"
+#line 674 "rl78-decode.opc"
           ID(mov); DRB(rba); SR(A);
         
         }
           case 0x70:
               {
                 /** 0111 0001 0bit 0000                set1    %e0%!0                          */
-#line 1022 "rl78-decode.opc"
+#line 1021 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("set1   %e0%!0");
-#line 1022 "rl78-decode.opc"
+#line 1021 "rl78-decode.opc"
                 ID(mov); DM(None, IMMU(2)); DB(bit); SC(1);
               
               }
           case 0x71:
               {
                 /** 0111 0001 0bit 0001                mov1    %0, cy                          */
-#line 779 "rl78-decode.opc"
+#line 778 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("mov1   %0, cy");
-#line 779 "rl78-decode.opc"
+#line 778 "rl78-decode.opc"
                 ID(mov); DM(None, SADDR); DB(bit); SCY();
               
               }
           case 0x72:
               {
                 /** 0111 0001 0bit 0010                set1    %0                              */
-#line 1040 "rl78-decode.opc"
+#line 1039 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("set1   %0");
-#line 1040 "rl78-decode.opc"
+#line 1039 "rl78-decode.opc"
                 ID(mov); DM(None, SADDR); DB(bit); SC(1);
               
               /*----------------------------------------------------------------------*/
           case 0x73:
               {
                 /** 0111 0001 0bit 0011                clr1    %0                              */
-#line 435 "rl78-decode.opc"
+#line 434 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("clr1   %0");
-#line 435 "rl78-decode.opc"
+#line 434 "rl78-decode.opc"
                 ID(mov); DM(None, SADDR); DB(bit); SC(0);
               
               /*----------------------------------------------------------------------*/
           case 0x74:
               {
                 /** 0111 0001 0bit 0100                mov1    cy, %1                          */
-#line 773 "rl78-decode.opc"
+#line 772 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("mov1   cy, %1");
-#line 773 "rl78-decode.opc"
+#line 772 "rl78-decode.opc"
                 ID(mov); DCY(); SM(None, SADDR); SB(bit);
               
               }
           case 0x75:
               {
                 /** 0111 0001 0bit 0101                and1    cy, %s1                         */
-#line 305 "rl78-decode.opc"
+#line 304 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("and1   cy, %s1");
-#line 305 "rl78-decode.opc"
+#line 304 "rl78-decode.opc"
                 ID(and); DCY(); SM(None, SADDR); SB(bit);
               
               /*----------------------------------------------------------------------*/
           case 0x76:
               {
                 /** 0111 0001 0bit 0110                or1     cy, %s1                         */
-#line 957 "rl78-decode.opc"
+#line 956 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("or1    cy, %s1");
-#line 957 "rl78-decode.opc"
+#line 956 "rl78-decode.opc"
                 ID(or); DCY(); SM(None, SADDR); SB(bit);
               
               /*----------------------------------------------------------------------*/
           case 0x77:
               {
                 /** 0111 0001 0bit 0111                xor1    cy, %s1                         */
-#line 1261 "rl78-decode.opc"
+#line 1260 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("xor1   cy, %s1");
-#line 1261 "rl78-decode.opc"
+#line 1260 "rl78-decode.opc"
                 ID(xor); DCY(); SM(None, SADDR); SB(bit);
               
               /*----------------------------------------------------------------------*/
           case 0x78:
               {
                 /** 0111 0001 0bit 1000                clr1    %e0%!0                          */
-#line 417 "rl78-decode.opc"
+#line 416 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("clr1   %e0%!0");
-#line 417 "rl78-decode.opc"
+#line 416 "rl78-decode.opc"
                 ID(mov); DM(None, IMMU(2)); DB(bit); SC(0);
               
               }
           case 0x79:
               {
                 /** 0111 0001 0bit 1001                mov1    %s0, cy                         */
-#line 782 "rl78-decode.opc"
+#line 781 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("mov1   %s0, cy");
-#line 782 "rl78-decode.opc"
+#line 781 "rl78-decode.opc"
                 ID(mov); DM(None, SFR); DB(bit); SCY();
               
               /*----------------------------------------------------------------------*/
           case 0x7a:
               {
                 /** 0111 0001 0bit 1010                set1    %s0                             */
-#line 1034 "rl78-decode.opc"
+#line 1033 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("set1   %s0");
-#line 1034 "rl78-decode.opc"
+#line 1033 "rl78-decode.opc"
                 op0 = SFR;
                 ID(mov); DM(None, op0); DB(bit); SC(1);
                 if (op0 == RL78_SFR_PSW && bit == 7)
           case 0x7b:
               {
                 /** 0111 0001 0bit 1011                clr1    %s0                             */
-#line 429 "rl78-decode.opc"
+#line 428 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("clr1   %s0");
-#line 429 "rl78-decode.opc"
+#line 428 "rl78-decode.opc"
                 op0 = SFR;
                 ID(mov); DM(None, op0); DB(bit); SC(0);
                 if (op0 == RL78_SFR_PSW && bit == 7)
           case 0x7c:
               {
                 /** 0111 0001 0bit 1100                mov1    cy, %s1                         */
-#line 776 "rl78-decode.opc"
+#line 775 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("mov1   cy, %s1");
-#line 776 "rl78-decode.opc"
+#line 775 "rl78-decode.opc"
                 ID(mov); DCY(); SM(None, SFR); SB(bit);
               
               }
           case 0x7d:
               {
                 /** 0111 0001 0bit 1101                and1    cy, %s1                         */
-#line 302 "rl78-decode.opc"
+#line 301 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("and1   cy, %s1");
-#line 302 "rl78-decode.opc"
+#line 301 "rl78-decode.opc"
                 ID(and); DCY(); SM(None, SFR); SB(bit);
               
               }
           case 0x7e:
               {
                 /** 0111 0001 0bit 1110                or1     cy, %s1                         */
-#line 954 "rl78-decode.opc"
+#line 953 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("or1    cy, %s1");
-#line 954 "rl78-decode.opc"
+#line 953 "rl78-decode.opc"
                 ID(or); DCY(); SM(None, SFR); SB(bit);
               
               }
           case 0x7f:
               {
                 /** 0111 0001 0bit 1111                xor1    cy, %s1                         */
-#line 1258 "rl78-decode.opc"
+#line 1257 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("xor1   cy, %s1");
-#line 1258 "rl78-decode.opc"
+#line 1257 "rl78-decode.opc"
                 ID(xor); DCY(); SM(None, SFR); SB(bit);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("set1   cy");
-#line 1031 "rl78-decode.opc"
+#line 1030 "rl78-decode.opc"
                 ID(mov); DCY(); SC(1);
               
               }
           case 0xf1:
               {
                 /** 0111 0001 1bit 0001                mov1    %e0%0, cy                       */
-#line 761 "rl78-decode.opc"
+#line 760 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("mov1   %e0%0, cy");
-#line 761 "rl78-decode.opc"
+#line 760 "rl78-decode.opc"
                 ID(mov); DM(HL, 0); DB(bit); SCY();
               
               }
           case 0xf2:
               {
                 /** 0111 0001 1bit 0010                set1    %e0%0                           */
-#line 1025 "rl78-decode.opc"
+#line 1024 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("set1   %e0%0");
-#line 1025 "rl78-decode.opc"
+#line 1024 "rl78-decode.opc"
                 ID(mov); DM(HL, 0); DB(bit); SC(1);
               
               }
           case 0xf3:
               {
                 /** 0111 0001 1bit 0011                clr1    %e0%0                           */
-#line 420 "rl78-decode.opc"
+#line 419 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("clr1   %e0%0");
-#line 420 "rl78-decode.opc"
+#line 419 "rl78-decode.opc"
                 ID(mov); DM(HL, 0); DB(bit); SC(0);
               
               }
           case 0xf4:
               {
                 /** 0111 0001 1bit 0100                mov1    cy, %e1%1                       */
-#line 767 "rl78-decode.opc"
+#line 766 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("mov1   cy, %e1%1");
-#line 767 "rl78-decode.opc"
+#line 766 "rl78-decode.opc"
                 ID(mov); DCY(); SM(HL, 0); SB(bit);
               
               }
           case 0xf5:
               {
                 /** 0111 0001 1bit 0101                and1    cy, %e1%1                       */
-#line 296 "rl78-decode.opc"
+#line 295 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("and1   cy, %e1%1");
-#line 296 "rl78-decode.opc"
+#line 295 "rl78-decode.opc"
                 ID(and); DCY(); SM(HL, 0); SB(bit);
               
               }
           case 0xf6:
               {
                 /** 0111 0001 1bit 0110                or1     cy, %e1%1                       */
-#line 948 "rl78-decode.opc"
+#line 947 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("or1    cy, %e1%1");
-#line 948 "rl78-decode.opc"
+#line 947 "rl78-decode.opc"
                 ID(or); DCY(); SM(HL, 0); SB(bit);
               
               }
           case 0xf7:
               {
                 /** 0111 0001 1bit 0111                xor1    cy, %e1%1                       */
-#line 1252 "rl78-decode.opc"
+#line 1251 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("xor1   cy, %e1%1");
-#line 1252 "rl78-decode.opc"
+#line 1251 "rl78-decode.opc"
                 ID(xor); DCY(); SM(HL, 0); SB(bit);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("clr1   cy");
-#line 426 "rl78-decode.opc"
+#line 425 "rl78-decode.opc"
                 ID(mov); DCY(); SC(0);
               
               }
           case 0xf9:
               {
                 /** 0111 0001 1bit 1001                mov1    %e0%0, cy                       */
-#line 764 "rl78-decode.opc"
+#line 763 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("mov1   %e0%0, cy");
-#line 764 "rl78-decode.opc"
+#line 763 "rl78-decode.opc"
                 ID(mov); DR(A); DB(bit); SCY();
               
               }
           case 0xfa:
               {
                 /** 0111 0001 1bit 1010                set1    %0                              */
-#line 1028 "rl78-decode.opc"
+#line 1027 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("set1   %0");
-#line 1028 "rl78-decode.opc"
+#line 1027 "rl78-decode.opc"
                 ID(mov); DR(A); DB(bit); SC(1);
               
               }
           case 0xfb:
               {
                 /** 0111 0001 1bit 1011                clr1    %0                              */
-#line 423 "rl78-decode.opc"
+#line 422 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("clr1   %0");
-#line 423 "rl78-decode.opc"
+#line 422 "rl78-decode.opc"
                 ID(mov); DR(A); DB(bit); SC(0);
               
               }
           case 0xfc:
               {
                 /** 0111 0001 1bit 1100                mov1    cy, %e1%1                       */
-#line 770 "rl78-decode.opc"
+#line 769 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("mov1   cy, %e1%1");
-#line 770 "rl78-decode.opc"
+#line 769 "rl78-decode.opc"
                 ID(mov); DCY(); SR(A); SB(bit);
               
               }
           case 0xfd:
               {
                 /** 0111 0001 1bit 1101                and1    cy, %1                          */
-#line 299 "rl78-decode.opc"
+#line 298 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("and1   cy, %1");
-#line 299 "rl78-decode.opc"
+#line 298 "rl78-decode.opc"
                 ID(and); DCY(); SR(A); SB(bit);
               
               }
           case 0xfe:
               {
                 /** 0111 0001 1bit 1110                or1     cy, %1                          */
-#line 951 "rl78-decode.opc"
+#line 950 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("or1    cy, %1");
-#line 951 "rl78-decode.opc"
+#line 950 "rl78-decode.opc"
                 ID(or); DCY(); SR(A); SB(bit);
               
               }
           case 0xff:
               {
                 /** 0111 0001 1bit 1111                xor1    cy, %1                          */
-#line 1255 "rl78-decode.opc"
+#line 1254 "rl78-decode.opc"
                 int bit AU = (op[1] >> 4) & 0x07;
                 if (trace)
                   {
                     printf ("  bit = 0x%x\n", bit);
                   }
                 SYNTAX("xor1   cy, %1");
-#line 1255 "rl78-decode.opc"
+#line 1254 "rl78-decode.opc"
                 ID(xor); DCY(); SR(A); SB(bit);
               
               }
                            op[0], op[1]);
                   }
                 SYNTAX("not1   cy");
-#line 892 "rl78-decode.opc"
+#line 891 "rl78-decode.opc"
                 ID(xor); DCY(); SC(1);
               
               /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("movw %e0%0, %1");
-#line 853 "rl78-decode.opc"
+#line 852 "rl78-decode.opc"
           ID(mov); W(); DM(BC, IMMU(2)); SR(AX);
         
         }
                      op[0]);
             }
           SYNTAX("movw %0, %e1%1");
-#line 844 "rl78-decode.opc"
+#line 843 "rl78-decode.opc"
           ID(mov); W(); DR(AX); SM(BC, IMMU(2));
         
         }
                      op[0]);
             }
           SYNTAX("xor  %0, #%1");
-#line 1247 "rl78-decode.opc"
+#line 1246 "rl78-decode.opc"
           ID(xor); DM(None, SADDR); SC(IMMU(1)); Fz;
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("xor  %0, %1");
-#line 1244 "rl78-decode.opc"
+#line 1243 "rl78-decode.opc"
           ID(xor); DR(A); SM(None, SADDR); Fz;
         
         }
                      op[0]);
             }
           SYNTAX("xor  %0, #%1");
-#line 1235 "rl78-decode.opc"
+#line 1234 "rl78-decode.opc"
           ID(xor); DR(A); SC(IMMU(1)); Fz;
         
         }
                      op[0]);
             }
           SYNTAX("xor  %0, %e1%1");
-#line 1223 "rl78-decode.opc"
+#line 1222 "rl78-decode.opc"
           ID(xor); DR(A); SM(HL, 0); Fz;
         
         }
                      op[0]);
             }
           SYNTAX("xor  %0, %e1%1");
-#line 1229 "rl78-decode.opc"
+#line 1228 "rl78-decode.opc"
           ID(xor); DR(A); SM(HL, IMMU(1)); Fz;
         
         }
                      op[0]);
             }
           SYNTAX("xor  %0, %e1%!1");
-#line 1220 "rl78-decode.opc"
+#line 1219 "rl78-decode.opc"
           ID(xor); DR(A); SM(None, IMMU(2)); Fz;
         
         }
     case 0x87:
         {
           /** 1000 0reg                        inc     %0                              */
-#line 566 "rl78-decode.opc"
+#line 565 "rl78-decode.opc"
           int reg AU = op[0] & 0x07;
           if (trace)
             {
               printf ("  reg = 0x%x\n", reg);
             }
           SYNTAX("inc  %0");
-#line 566 "rl78-decode.opc"
+#line 565 "rl78-decode.opc"
           ID(add); DRB(reg); SC(1); Fza;
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %e1%1");
-#line 645 "rl78-decode.opc"
+#line 644 "rl78-decode.opc"
           ID(mov); DR(A); SM(SP, IMMU(1));
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %e1%1");
-#line 627 "rl78-decode.opc"
+#line 626 "rl78-decode.opc"
           ID(mov); DR(A); SM(DE, 0);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %e1%1");
-#line 630 "rl78-decode.opc"
+#line 629 "rl78-decode.opc"
           ID(mov); DR(A); SM(DE, IMMU(1));
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %e1%1");
-#line 633 "rl78-decode.opc"
+#line 632 "rl78-decode.opc"
           ID(mov); DR(A); SM(HL, 0);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %e1%1");
-#line 636 "rl78-decode.opc"
+#line 635 "rl78-decode.opc"
           ID(mov); DR(A); SM(HL, IMMU(1));
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %1");
-#line 669 "rl78-decode.opc"
+#line 668 "rl78-decode.opc"
           ID(mov); DR(A); SM(None, SADDR);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %s1");
-#line 666 "rl78-decode.opc"
+#line 665 "rl78-decode.opc"
           ID(mov); DR(A); SM(None, SFR);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %e1%!1");
-#line 624 "rl78-decode.opc"
+#line 623 "rl78-decode.opc"
           ID(mov); DR(A); SM(None, IMMU(2));
         
         }
     case 0x97:
         {
           /** 1001 0reg                        dec     %0                              */
-#line 533 "rl78-decode.opc"
+#line 532 "rl78-decode.opc"
           int reg AU = op[0] & 0x07;
           if (trace)
             {
               printf ("  reg = 0x%x\n", reg);
             }
           SYNTAX("dec  %0");
-#line 533 "rl78-decode.opc"
+#line 532 "rl78-decode.opc"
           ID(sub); DRB(reg); SC(1); Fza;
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %1");
-#line 621 "rl78-decode.opc"
+#line 620 "rl78-decode.opc"
           ID(mov); DM(SP, IMMU(1)); SR(A);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %e0%0,%1");
-#line 594 "rl78-decode.opc"
+#line 593 "rl78-decode.opc"
           ID(mov); DM(DE, 0); SR(A);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %e0%0, %1");
-#line 600 "rl78-decode.opc"
+#line 599 "rl78-decode.opc"
           ID(mov); DM(DE, IMMU(1)); SR(A);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %e0%0,%1");
-#line 603 "rl78-decode.opc"
+#line 602 "rl78-decode.opc"
           ID(mov); DM(HL, 0); SR(A);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %e0%0, %1");
-#line 612 "rl78-decode.opc"
+#line 611 "rl78-decode.opc"
           ID(mov); DM(HL, IMMU(1)); SR(A);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %1");
-#line 726 "rl78-decode.opc"
+#line 725 "rl78-decode.opc"
           ID(mov); DM(None, SADDR); SR(A);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %1");
-#line 756 "rl78-decode.opc"
+#line 755 "rl78-decode.opc"
           ID(mov); DM(None, SFR); SR(A);
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("mov  %e0%!0, %1");
-#line 591 "rl78-decode.opc"
+#line 590 "rl78-decode.opc"
           ID(mov); DM(None, IMMU(2)); SR(A);
         
         }
                      op[0]);
             }
           SYNTAX("inc  %e0%!0");
-#line 560 "rl78-decode.opc"
+#line 559 "rl78-decode.opc"
           ID(add); DM(None, IMMU(2)); SC(1); Fza;
         
         }
     case 0xa7:
         {
           /** 1010 0rg1                        incw    %0                              */
-#line 580 "rl78-decode.opc"
+#line 579 "rl78-decode.opc"
           int rg AU = (op[0] >> 1) & 0x03;
           if (trace)
             {
               printf ("  rg = 0x%x\n", rg);
             }
           SYNTAX("incw %0");
-#line 580 "rl78-decode.opc"
+#line 579 "rl78-decode.opc"
           ID(add); W(); DRW(rg); SC(1);
         
         }
                      op[0]);
             }
           SYNTAX("incw %e0%!0");
-#line 574 "rl78-decode.opc"
+#line 573 "rl78-decode.opc"
           ID(add); W(); DM(None, IMMU(2)); SC(1);
         
         }
                      op[0]);
             }
           SYNTAX("inc  %0");
-#line 569 "rl78-decode.opc"
+#line 568 "rl78-decode.opc"
           ID(add); DM(None, SADDR); SC(1); Fza;
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("incw %0");
-#line 583 "rl78-decode.opc"
+#line 582 "rl78-decode.opc"
           ID(add); W(); DM(None, SADDR); SC(1);
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("movw %0, %1");
-#line 826 "rl78-decode.opc"
+#line 825 "rl78-decode.opc"
           ID(mov); W(); DR(AX); SM(SP, IMMU(1));
         
         }
                      op[0]);
             }
           SYNTAX("movw %0, %e1%1");
-#line 814 "rl78-decode.opc"
+#line 813 "rl78-decode.opc"
           ID(mov); W(); DR(AX); SM(DE, 0);
         
         }
                      op[0]);
             }
           SYNTAX("movw %0, %e1%1");
-#line 817 "rl78-decode.opc"
+#line 816 "rl78-decode.opc"
           ID(mov); W(); DR(AX); SM(DE, IMMU(1));
         
         }
                      op[0]);
             }
           SYNTAX("movw %0, %e1%1");
-#line 820 "rl78-decode.opc"
+#line 819 "rl78-decode.opc"
           ID(mov); W(); DR(AX); SM(HL, 0);
         
         }
                      op[0]);
             }
           SYNTAX("movw %0, %e1%1");
-#line 823 "rl78-decode.opc"
+#line 822 "rl78-decode.opc"
           ID(mov); W(); DR(AX); SM(HL, IMMU(1));
         
         }
                      op[0]);
             }
           SYNTAX("movw %0, %1");
-#line 856 "rl78-decode.opc"
+#line 855 "rl78-decode.opc"
           ID(mov); W(); DR(AX); SM(None, SADDR);
         
         }
                      op[0]);
             }
           SYNTAX("movw %0, %s1");
-#line 859 "rl78-decode.opc"
+#line 858 "rl78-decode.opc"
           ID(mov); W(); DR(AX); SM(None, SFR);
         
         }
                      op[0]);
             }
           SYNTAX("movw %0, %e1%!1");
-#line 810 "rl78-decode.opc"
+#line 809 "rl78-decode.opc"
           ID(mov); W(); DR(AX); SM(None, IMMU(2));
         
         
                      op[0]);
             }
           SYNTAX("dec  %e0%!0");
-#line 527 "rl78-decode.opc"
+#line 526 "rl78-decode.opc"
           ID(sub); DM(None, IMMU(2)); SC(1); Fza;
         
         }
     case 0xb7:
         {
           /** 1011 0rg1                        decw    %0                              */
-#line 547 "rl78-decode.opc"
+#line 546 "rl78-decode.opc"
           int rg AU = (op[0] >> 1) & 0x03;
           if (trace)
             {
               printf ("  rg = 0x%x\n", rg);
             }
           SYNTAX("decw %0");
-#line 547 "rl78-decode.opc"
+#line 546 "rl78-decode.opc"
           ID(sub); W(); DRW(rg); SC(1);
         
         }
                      op[0]);
             }
           SYNTAX("decw %e0%!0");
-#line 541 "rl78-decode.opc"
+#line 540 "rl78-decode.opc"
           ID(sub); W(); DM(None, IMMU(2)); SC(1);
         
         }
                      op[0]);
             }
           SYNTAX("dec  %0");
-#line 536 "rl78-decode.opc"
+#line 535 "rl78-decode.opc"
           ID(sub); DM(None, SADDR); SC(1); Fza;
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("decw %0");
-#line 550 "rl78-decode.opc"
+#line 549 "rl78-decode.opc"
           ID(sub); W(); DM(None, SADDR); SC(1);
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("movw %0, %1");
-#line 807 "rl78-decode.opc"
+#line 806 "rl78-decode.opc"
           ID(mov); W(); DM(SP, IMMU(1)); SR(AX);
         
         }
                      op[0]);
             }
           SYNTAX("movw %e0%0, %1");
-#line 795 "rl78-decode.opc"
+#line 794 "rl78-decode.opc"
           ID(mov); W(); DM(DE, 0); SR(AX);
         
         }
                      op[0]);
             }
           SYNTAX("movw %e0%0, %1");
-#line 798 "rl78-decode.opc"
+#line 797 "rl78-decode.opc"
           ID(mov); W(); DM(DE, IMMU(1)); SR(AX);
         
         }
                      op[0]);
             }
           SYNTAX("movw %e0%0, %1");
-#line 801 "rl78-decode.opc"
+#line 800 "rl78-decode.opc"
           ID(mov); W(); DM(HL, 0); SR(AX);
         
         }
                      op[0]);
             }
           SYNTAX("movw %e0%0, %1");
-#line 804 "rl78-decode.opc"
+#line 803 "rl78-decode.opc"
           ID(mov); W(); DM(HL, IMMU(1)); SR(AX);
         
         }
                      op[0]);
             }
           SYNTAX("movw %0, %1");
-#line 871 "rl78-decode.opc"
+#line 870 "rl78-decode.opc"
           ID(mov); W(); DM(None, SADDR); SR(AX);
         
         }
                      op[0]);
             }
           SYNTAX("movw %0, %1");
-#line 877 "rl78-decode.opc"
+#line 876 "rl78-decode.opc"
           ID(mov); W(); DM(None, SFR); SR(AX);
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("movw %e0%!0, %1");
-#line 792 "rl78-decode.opc"
+#line 791 "rl78-decode.opc"
           ID(mov); W(); DM(None, IMMU(2)); SR(AX);
         
         }
     case 0xc6:
         {
           /** 1100 0rg0                        pop     %0                              */
-#line 962 "rl78-decode.opc"
+#line 961 "rl78-decode.opc"
           int rg AU = (op[0] >> 1) & 0x03;
           if (trace)
             {
               printf ("  rg = 0x%x\n", rg);
             }
           SYNTAX("pop  %0");
-#line 962 "rl78-decode.opc"
+#line 961 "rl78-decode.opc"
           ID(mov); W(); DRW(rg); SPOP();
         
         }
     case 0xc7:
         {
           /** 1100 0rg1                        push    %1                              */
-#line 970 "rl78-decode.opc"
+#line 969 "rl78-decode.opc"
           int rg AU = (op[0] >> 1) & 0x03;
           if (trace)
             {
               printf ("  rg = 0x%x\n", rg);
             }
           SYNTAX("push %1");
-#line 970 "rl78-decode.opc"
+#line 969 "rl78-decode.opc"
           ID(mov); W(); DPUSH(); SRW(rg);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, #%1");
-#line 618 "rl78-decode.opc"
+#line 617 "rl78-decode.opc"
           ID(mov); DM(SP, IMMU(1)); SC(IMMU(1));
         
         }
                      op[0]);
             }
           SYNTAX("movw %0, #%1");
-#line 868 "rl78-decode.opc"
+#line 867 "rl78-decode.opc"
           ID(mov); W(); DM(None, SADDR); SC(IMMU(2));
         
         }
                      op[0]);
             }
           SYNTAX("mov  %e0%0, #%1");
-#line 597 "rl78-decode.opc"
+#line 596 "rl78-decode.opc"
           ID(mov); DM(DE, IMMU(1)); SC(IMMU(1));
         
         }
                      op[0]);
             }
           SYNTAX("movw %0, #%1");
-#line 874 "rl78-decode.opc"
+#line 873 "rl78-decode.opc"
           ID(mov); W(); DM(None, SFR); SC(IMMU(2));
         
         }
                      op[0]);
             }
           SYNTAX("mov  %e0%0, #%1");
-#line 609 "rl78-decode.opc"
+#line 608 "rl78-decode.opc"
           ID(mov); DM(HL, IMMU(1)); SC(IMMU(1));
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, #%1");
-#line 723 "rl78-decode.opc"
+#line 722 "rl78-decode.opc"
           ID(mov); DM(None, SADDR); SC(IMMU(1));
         
         }
                      op[0]);
             }
           SYNTAX("mov  %s0, #%1");
-#line 729 "rl78-decode.opc"
+#line 728 "rl78-decode.opc"
           op0 = SFR;
           op1 = IMMU(1);
           ID(mov); DM(None, op0); SC(op1);
                      op[0]);
             }
           SYNTAX("mov  %e0%!0, #%1");
-#line 588 "rl78-decode.opc"
+#line 587 "rl78-decode.opc"
           ID(mov); DM(None, IMMU(2)); SC(IMMU(1));
         
         }
     case 0xd3:
         {
           /** 1101 00rg                        cmp0    %0                              */
-#line 497 "rl78-decode.opc"
+#line 496 "rl78-decode.opc"
           int rg AU = op[0] & 0x03;
           if (trace)
             {
               printf ("  rg = 0x%x\n", rg);
             }
           SYNTAX("cmp0 %0");
-#line 497 "rl78-decode.opc"
+#line 496 "rl78-decode.opc"
           ID(cmp); DRB(rg); SC(0); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("cmp0 %0");
-#line 500 "rl78-decode.opc"
+#line 499 "rl78-decode.opc"
           ID(cmp); DM(None, SADDR); SC(0); Fzac;
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("cmp0 %e0%!0");
-#line 494 "rl78-decode.opc"
+#line 493 "rl78-decode.opc"
           ID(cmp); DM(None, IMMU(2)); SC(0); Fzac;
         
         }
                      op[0]);
             }
           SYNTAX("mulu x");
-#line 882 "rl78-decode.opc"
+#line 881 "rl78-decode.opc"
           ID(mulu);
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("ret");
-#line 978 "rl78-decode.opc"
+#line 977 "rl78-decode.opc"
           ID(ret);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %1");
-#line 690 "rl78-decode.opc"
+#line 689 "rl78-decode.opc"
           ID(mov); DR(X); SM(None, SADDR);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %e1%!1");
-#line 687 "rl78-decode.opc"
+#line 686 "rl78-decode.opc"
           ID(mov); DR(X); SM(None, IMMU(2));
         
         }
     case 0xfa:
         {
           /** 11ra 1010                        movw    %0, %1                          */
-#line 865 "rl78-decode.opc"
+#line 864 "rl78-decode.opc"
           int ra AU = (op[0] >> 4) & 0x03;
           if (trace)
             {
               printf ("  ra = 0x%x\n", ra);
             }
           SYNTAX("movw %0, %1");
-#line 865 "rl78-decode.opc"
+#line 864 "rl78-decode.opc"
           ID(mov); W(); DRW(ra); SM(None, SADDR);
         
         }
     case 0xfb:
         {
           /** 11ra 1011                        movw    %0, %e1%!1                      */
-#line 862 "rl78-decode.opc"
+#line 861 "rl78-decode.opc"
           int ra AU = (op[0] >> 4) & 0x03;
           if (trace)
             {
               printf ("  ra = 0x%x\n", ra);
             }
           SYNTAX("movw %0, %e1%!1");
-#line 862 "rl78-decode.opc"
+#line 861 "rl78-decode.opc"
           ID(mov); W(); DRW(ra); SM(None, IMMU(2));
         
         }
                      op[0]);
             }
           SYNTAX("bc   $%a0");
-#line 313 "rl78-decode.opc"
+#line 312 "rl78-decode.opc"
           ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(C);
         
         }
                      op[0]);
             }
           SYNTAX("bz   $%a0");
-#line 325 "rl78-decode.opc"
+#line 324 "rl78-decode.opc"
           ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(Z);
         
         }
                      op[0]);
             }
           SYNTAX("bnc  $%a0");
-#line 316 "rl78-decode.opc"
+#line 315 "rl78-decode.opc"
           ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(NC);
         
         }
                      op[0]);
             }
           SYNTAX("bnz  $%a0");
-#line 328 "rl78-decode.opc"
+#line 327 "rl78-decode.opc"
           ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(NZ);
         
         /*----------------------------------------------------------------------*/
     case 0xe3:
         {
           /** 1110 00rg                        oneb    %0                              */
-#line 900 "rl78-decode.opc"
+#line 899 "rl78-decode.opc"
           int rg AU = op[0] & 0x03;
           if (trace)
             {
               printf ("  rg = 0x%x\n", rg);
             }
           SYNTAX("oneb %0");
-#line 900 "rl78-decode.opc"
+#line 899 "rl78-decode.opc"
           ID(mov); DRB(rg); SC(1);
         
         }
                      op[0]);
             }
           SYNTAX("oneb %0");
-#line 903 "rl78-decode.opc"
+#line 902 "rl78-decode.opc"
           ID(mov); DM(None, SADDR); SC(1);
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("oneb %e0%!0");
-#line 897 "rl78-decode.opc"
+#line 896 "rl78-decode.opc"
           ID(mov); DM(None, IMMU(2)); SC(1);
         
         }
                      op[0]);
             }
           SYNTAX("onew %0");
-#line 908 "rl78-decode.opc"
+#line 907 "rl78-decode.opc"
           ID(mov); DR(AX); SC(1);
         
         }
                      op[0]);
             }
           SYNTAX("onew %0");
-#line 911 "rl78-decode.opc"
+#line 910 "rl78-decode.opc"
           ID(mov); DR(BC); SC(1);
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("mov  %0, %1");
-#line 678 "rl78-decode.opc"
+#line 677 "rl78-decode.opc"
           ID(mov); DR(B); SM(None, SADDR);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %e1%!1");
-#line 672 "rl78-decode.opc"
+#line 671 "rl78-decode.opc"
           ID(mov); DR(B); SM(None, IMMU(2));
         
         }
                      op[0]);
             }
           SYNTAX("br   !%!a0");
-#line 347 "rl78-decode.opc"
+#line 346 "rl78-decode.opc"
           ID(branch); DC(IMMU(3));
         
         }
                      op[0]);
             }
           SYNTAX("br   %!a0");
-#line 350 "rl78-decode.opc"
+#line 349 "rl78-decode.opc"
           ID(branch); DC(IMMU(2));
         
         }
                      op[0]);
             }
           SYNTAX("br   $%!a0");
-#line 353 "rl78-decode.opc"
+#line 352 "rl78-decode.opc"
           ID(branch); DC(pc+IMMS(2)+3);
         
         }
                      op[0]);
             }
           SYNTAX("br   $%a0");
-#line 356 "rl78-decode.opc"
+#line 355 "rl78-decode.opc"
           ID(branch); DC(pc+IMMS(1)+2);
         
         }
     case 0xf3:
         {
           /** 1111 00rg                        clrb    %0                              */
-#line 443 "rl78-decode.opc"
+#line 442 "rl78-decode.opc"
           int rg AU = op[0] & 0x03;
           if (trace)
             {
               printf ("  rg = 0x%x\n", rg);
             }
           SYNTAX("clrb %0");
-#line 443 "rl78-decode.opc"
+#line 442 "rl78-decode.opc"
           ID(mov); DRB(rg); SC(0);
         
         }
                      op[0]);
             }
           SYNTAX("clrb %0");
-#line 446 "rl78-decode.opc"
+#line 445 "rl78-decode.opc"
           ID(mov); DM(None, SADDR); SC(0);
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("clrb %e0%!0");
-#line 440 "rl78-decode.opc"
+#line 439 "rl78-decode.opc"
           ID(mov); DM(None, IMMU(2)); SC(0);
         
         }
                      op[0]);
             }
           SYNTAX("clrw %0");
-#line 451 "rl78-decode.opc"
+#line 450 "rl78-decode.opc"
           ID(mov); DR(AX); SC(0);
         
         }
                      op[0]);
             }
           SYNTAX("clrw %0");
-#line 454 "rl78-decode.opc"
+#line 453 "rl78-decode.opc"
           ID(mov); DR(BC); SC(0);
         
         /*----------------------------------------------------------------------*/
                      op[0]);
             }
           SYNTAX("mov  %0, %1");
-#line 684 "rl78-decode.opc"
+#line 683 "rl78-decode.opc"
           ID(mov); DR(C); SM(None, SADDR);
         
         }
                      op[0]);
             }
           SYNTAX("mov  %0, %e1%!1");
-#line 681 "rl78-decode.opc"
+#line 680 "rl78-decode.opc"
           ID(mov); DR(C); SM(None, IMMU(2));
         
         }
                      op[0]);
             }
           SYNTAX("call !%!a0");
-#line 400 "rl78-decode.opc"
+#line 399 "rl78-decode.opc"
           ID(call); DC(IMMU(3));
         
         }
                      op[0]);
             }
           SYNTAX("call %!a0");
-#line 403 "rl78-decode.opc"
+#line 402 "rl78-decode.opc"
           ID(call); DC(IMMU(2));
         
         }
                      op[0]);
             }
           SYNTAX("call $%!a0");
-#line 406 "rl78-decode.opc"
+#line 405 "rl78-decode.opc"
           ID(call); DC(pc+IMMS(2)+3);
         
         }
                      op[0]);
             }
           SYNTAX("brk1");
-#line 364 "rl78-decode.opc"
+#line 363 "rl78-decode.opc"
           ID(break);
         
         }
       break;
   }
-#line 1266 "rl78-decode.opc"
+#line 1265 "rl78-decode.opc"
 
   return rl78->n_bytes;
 }