50元人民币求学习型遥控器就编程(有原理图)

xzmzone

自己已经画好原理图,希望有高手帮忙编程.50元不算高价,但我很真诚,先附上原理图,望大家指点,谢谢

联系xzmzone@126.com   QQ:97264446




(原文件名:111.jpg)

czzhouyun

还是学习型的，求程序的话如果说实话，好的程序你给10W都求不到，别看这简单，能搞定的国内也就寥寥几人，我能搞，你出不起价的

little_Monkey

50元，一天的工资都不到！做这个如果没做过的肯定不止一天，如果做过的也不会50元给你

xzmzone

其实真的很简单的,有些都只要用一些固定的模块就可以了,下面是原理图,大家看了就知道了,我也不是说50元能代表什么,只是迫切希望有人能帮我,所以就稍微意思一下,可能帮我的也不一定为了这50块钱

(原文件名:111.jpg)

little_Monkey

LZ考虑事情太简单了，2楼已经说了，好的程序给你10W都求不到，不要以为硬件简单软件也简单

xzmzone

这个程序是用89C51编的,还含液晶模块，我改了后液晶不用了,引脚稍有变化,所以只要在这基础上改一下就行了
//C51红外解码程序
#include <AT89X51.h>
#include<INTRINS.H>
#include<IR_data_Transmit.h>
#include "lcd1602.h"
#include "eeprom24c64.h"
#define uchar unsigned char
#define uint unsigned int
#define keyboard P1
sbit p32=P3^2;

uchar dm,i,j,k,kk;
uchar  a[4];
uchar l,m,n,p,q;
unsigned char  key,key_temp,study_counter;
bit key_flag;

bit flag;
uchar code coder[]="0123456789abcdef";
uchar ID[4]={0,0,0,0};

uchar ID1[4]={0,0,0,0};
uchar ID2[4]={0,0,0,0};
uchar ID3[4]={0,0,0,0};
uchar ID4[4]={0,0,0,0};

void ds1ms(void)
{
unsigned char i,j;
for(i=2;i>0;i--)
   for(j=230;j>0;j--) ;
}
/*********************************/
void ds0_9ms(void)
{
unsigned char j,k;
   for(j=18;j>0;j--)
     for(k=20;k>0;k--) ;
}

//////////////////////////////////////////////
void delay10MS()//延时时间有待调整
{
        unsigned char i,j;
        for(i = 0; i < 50; i++)
        {
                for(j = 0; j < 50; j++);
        }
}
/////////////////////////////////////////////////////
void keyscan()
{
  keyboard=0xff&0xfe;
  if(keyboard!=0xfe)
  {
   delay10MS();
         if(keyboard!=0xfe)
         {
           key_flag=1;
           key_temp=keyboard&0xff;
         switch(key_temp)
             {
       case 0x7e :key=0;break;
            case 0xbe :key=1;break ;
       case 0xde :key=2;break ;
       case 0xee :key=3;break ;
       default :break ;
             }
                  while(keyboard!=0xfe);
           }
  }

   keyboard=0xff&0xfd;
    if(keyboard!=0xfd)
  {
   delay10MS();
         if(keyboard!=0xfd)
         {
           key_flag=1;
           key_temp=keyboard&0xff;
         switch(key_temp)
             {
       case 0x7d :key=4;break;
            case 0xbd :key=5;break ;
       case 0xdd :key=6;break ;
       case 0xed :key=7;break ;
       default :break ;
             }
                 while(keyboard!=0xfd);
           }
  }

  keyboard=0xff&0xfb;
    if(keyboard!=0xfb)
  {
   delay10MS();
         if(keyboard!=0xfb)
         {
           key_flag=1;
           key_temp=keyboard&0xff;
         switch(key_temp)
             {
       case 0x7b :key=8;break;
            case 0xbb :key=9;break ;
       case 0xdb :key=10;break ;
       case 0xeb :key=11;break ;
       default :break ;
             }
                  while(keyboard!=0xfb);
           }
  }


  keyboard=0xff&0xf7;
    if(keyboard!=0xf7)
  {
   delay10MS();
         if(keyboard!=0xf7)
         {
           key_flag=1;
           key_temp=keyboard&0xff;
         switch(key_temp)
             {
       case 0x77 :key=12;break;
            case 0xb7 :key=13;break ;
       case 0xd7 :key=14;break ;
       case 0xe7 :key=15;break ;
       default :break ;
             }
                 while(keyboard!=0xf7);
           }
  }

}
///////////////////////////////////////////////////
void keywork()
{
if(key_flag){key_flag=0;IT0=0;EA=0;
/*
switch(key)
{
case 0:  RW24XX(ID2,4,0,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(0,1);break;
case 1:  RW24XX(ID2,4,4,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(2,3);break;
case 2:  RW24XX(ID2,4,8,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(4,5);break;
case 3:  RW24XX(ID2,4,12,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(6,7);break;
case 4:  RW24XX(ID2,4,16,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(8,9);break;
case 5:  RW24XX(ID2,4,20,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(10,11);break;
case 6:  RW24XX(ID2,4,24,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(12,13);break;
case 7:  RW24XX(ID2,4,28,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(14,15);break;
case 8:  RW24XX(ID2,4,32,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(16,17);break;
case 9:  RW24XX(ID2,4,36,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(18,19);break;
case 10:RW24XX(ID2,4,40,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(20,21);break;
case 11:RW24XX(ID2,4,44,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(22,23);break;
case 12:        RW24XX(ID,4,0,0xa0,M2402);//  写入四个数       
            Delay24c(158);
                         study_counter=study_counter+4;if(study_counter==48)study_counter=0;break;//OK
case 13:;break;
case 14:;break;
case 15:;break;
}
*/
//////////////////////////////////////////////////////

switch(key)
{
case 0:  RW24XX(ID2,4,0,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(ID2[2]*16+ID2[3],ID2[1]*16+ID2[0]);break;
case 1:  RW24XX(ID2,4,4,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(ID2[2]*16+ID2[3],ID2[1]*16+ID2[0]);break;
case 2:  RW24XX(ID2,4,8,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(ID2[2]*16+ID2[3],ID2[1]*16+ID2[0]);break;
case 3:  RW24XX(ID2,4,12,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(ID2[2]*16+ID2[3],ID2[1]*16+ID2[0]);break;
case 4:  RW24XX(ID2,4,16,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(ID2[2]*16+ID2[3],ID2[1]*16+ID2[0]);break;
case 5:  RW24XX(ID2,4,20,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(ID2[2]*16+ID2[3],ID2[1]*16+ID2[0]);break;
case 6:  RW24XX(ID2,4,24,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(ID2[2]*16+ID2[3],ID2[1]*16+ID2[0]);break;
case 7:  RW24XX(ID2,4,28,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(ID2[2]*16+ID2[3],ID2[1]*16+ID2[0]);break;
case 8:  RW24XX(ID2,4,32,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(ID2[2]*16+ID2[3],ID2[1]*16+ID2[0]);break;
case 9:  RW24XX(ID2,4,36,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(ID2[2]*16+ID2[3],ID2[1]*16+ID2[0]);break;
case 10:RW24XX(ID2,4,40,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(ID2[2]*16+ID2[3],ID2[1]*16+ID2[0]);break;
case 11:RW24XX(ID2,4,44,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);IR_data_Transmit(ID2[2]*16+ID2[3],ID2[1]*16+ID2[0]);break;
case 12:        RW24XX(ID,4,0,0xa0,M2402);//  写入四个数       
            Delay24c(158);
                         study_counter=study_counter+4;if(study_counter==48)study_counter=0;break;//OK
case 13:;break;
case 14:;break;
case 15:;break;
}IT0=1;EA=1;
//////////////////////////////////////////////////

}else LED=0;
}
////////////////////////////////////////////
void main()
{
lcd_init();
m=ID[0]; n=ID[1]; p=ID[2]; q=ID[3];
IT0=1;
EX0=1;
EA=1;
dm=0;
write_lcd_char(0,0,'I');
write_lcd_char(1,0,'D');
write_lcd_char(2,0,' ');
write_lcd_char(3,0,'c');
write_lcd_char(4,0,'o');
write_lcd_char(5,0,'d');
write_lcd_char(6,0,'e');
write_lcd_char(7,0,':');
write_lcd_char(8,0,' ');
write_lcd_char(10,0,'0');
write_lcd_char(11,0,'x');
while(1)
{         // EA=0;
                    // kk++;delay(500);
          //IR_data_Transmit(51,kk);
         // EA=1;
//IR_data_Transmit(6,35);               
keyscan();
keywork();


write_lcd_char(15,1,coder[key]);
write_lcd_char(13,1,coder[study_counter/4]);
write_lcd_char(12,1,coder[study_counter%4]);

write_lcd_char(12,0,coder[ID[3]]);
write_lcd_char(13,0,coder[ID[2]]);
write_lcd_char(14,0,coder[ID[1]]);
write_lcd_char(15,0,coder[ID[0]]);
/////////////////////////////////////////////
write_lcd_char(0,1,coder[ID2[2]]);
write_lcd_char(1,1,coder[ID2[3]]);
write_lcd_char(2,1,coder[ID2[1]]);
write_lcd_char(3,1,coder[ID2[0]]);



/*
if(flag)
{
  RW24XX(ID,4,study_counter,0xa0,M2402);//  写入四个数       
             Delay24c(158);

  flag=0;
}

*/

/*
if(!key0)
        {          
                     IT0=0; EX0=0;                          
              IR_data_Transmit(16,8);       
                    } else{ IT0=1;EX0=1;}
if(!key1)
        {   T0=0; EX0=0;
                       RW24XX(ID2,4,0,0xa1,M2402);//读出4个数，放在ID里。
              Delay24c(158);   
             IR_data_Transmit(ID2[2]*16+ID2[3],ID2[1]*16+ID2[0]);
                    }else{ IT0=1;EX0=1;}

if(!key2)
        {          IT0=0; EX0=0;                     
             IR_data_Transmit(5,35);       
                    } else{ IT0=1;EX0=1;}
*/
}
}

/***********************************************************************************************/
void t0_1(void) interrupt 0 using 2
{  uchar DL,DH,a0;
    EA=0;
        for(k=0;k<1;k++) //是否9ms的红外引导码？
   {
    ds0_9ms();
    if (p32==1) {;break;}
        ds0_9ms();               
    if (p32==1) {;break;}
/*        ds0_9ms();
    if (p32==1) {;break;}
        ds0_9ms();
    if (p32==1) {;break;}
        ds0_9ms();
    if (p32==1) {;break;}
        ds0_9ms();
    if (p32==1) {;break;}
        ds0_9ms();
    if (p32==1) {;break;}
        ds0_9ms();
    if (p32==1) {;break;}
        ds0_9ms();
    if (p32==1) {;break;}
     */
     while(p32==0);
         ds0_9ms();ds0_9ms();ds0_9ms();a0=p32;
                if(a0==1)
                {   while(p32==1);   
            for(i=0;i<4;i++)
             {
                 for(j=1;j<=8;j++)
                {
                  while(p32==0);
                  ds0_9ms();
                  if(p32==1)
                   { ds1ms();
                     dm=dm|0x80;
                     if(j<8) dm=dm>>1;
                    }
                   else  
                                         if(j<8)dm=dm>>1;
                 }
               a=dm;
               dm=0;
             }
                 }
     }
  DL=0X0F&a[2];
             DH=a[2];
  DH=DH>>4;
         m=DL;
           n=DH;
  DL=0X0F&a[0];
             DH=a[0];
  DH=DH>>4;
         q=DL;
           p=DH;
  EA=1;
  flag=1;
  ID[0]=m;  ID[1]=n; ID[2]=p; ID[3]=q;
}
//IR_data_Transmit();

sbit LED=P3^2;
void Transmit(int c1,int c2) //c1为高电平宽度
{unsigned char i;              //c2为低电平宽度
do{LED=0;             //产生38kHz载波       
    for(i=8;i>0;i--); //延时18us
    LED=0;
   }while(--c1);
        LED=1;
while(--c2);
}

void IR_data_Transmit(unsigned char a,c)
{  unsigned char Data[4];
   unsigned char b,d,i,j;
   b=255-a;d=255-c;
   Data[0]=a;
   Data[1]=b;
   Data[2]=c;
   Data[3]=d;
   Transmit(340,565); //发射引导码
   for(i=0;i<4;i++)
      for(j=0;j<8;j++) //发射帧数据
        {if((Data>>j)&1)
                   Transmit(19,205); //‘1’码
         else  Transmit(19,70);  //‘0’码
        }
    Transmit(19,17);
}



//EEPROM   IIC24C04

#pragma ot(6,SIZE)
#include <intrins.h>
#define ERRORCOUNT 10
sbit SDA=P1^1;
sbit SCL=P1^0;
enum eepromtype  {M2401,M2402,M2404,M2408,M2416,M2432,M2464,M24128,M24256};
enum eepromtype EepromType;



//DataBuff为读写数据输入／输出缓冲区的首址
//ByteQuantity 为要读写数据的字节数量
//Address 为EEPROM的片内地址
//ControlByte 为EEPROM的控制字节，具体形式为(1)(0)(1)(0)(A2)(A1)(A0)(R/W),其中R/W=1,
//表示读操作,R/W=0为写操作,A2,A1,A0为EEPROM的页选或片选地址;
//EepromType为枚举变量,需为M2401至M24256中的一种,分别对应24C01至24C256;
//函数返回值为一个位变量，若返回1表示此次操作失效，0表示操作成功;
//ERRORCOUNT为允许最大次数，若出现ERRORCOUNT次操作失效后，则函数中止操作，并返回1
//SDA和SCL由用户自定义
//其余的用户不用管，只要把只子程序放在你的程序中并调用它就可以了;


/*****************************************************************************/
bit   RW24XX(unsigned char *DataBuff,unsigned char ByteQuantity,unsigned int Address,
                     unsigned char ControlByte,enum eepromtype EepromType)
{
void Delay24c(unsigned char Delay24cCount);
void IICStart(void);
void IICStop(void);
bit  IICRecAck(void);
void IICNoAck(void);
void IICAck(void);
unsigned char IICReceiveByte(void);
void IICSendByte(unsigned char sendbyte);
unsigned char data j,i=ERRORCOUNT;
bit      errorflag=1;
while(i--)
   {
   IICStart();
   IICSendByte(ControlByte&0xfe);
   if(IICRecAck())
       continue;
   if(EepromType>M2416)
      {
      IICSendByte((unsigned char)(Address>>8));
      if(IICRecAck())
         continue;
      }
   IICSendByte((unsigned char)Address);
   if(IICRecAck())
       continue;
   if(!(ControlByte&0x01))
      {
      j=ByteQuantity;
      errorflag=0;                      //********clr errorflag
      while(j--)
        {
        IICSendByte(*DataBuff++);
        if(!IICRecAck())
           continue;
        errorflag=1;
        break;
        }
      if(errorflag==1)
        continue;
      break;
      }
   else
     {
     IICStart();
     IICSendByte(ControlByte);
     if(IICRecAck())
       continue;
     while(--ByteQuantity)
       {
       *DataBuff++=IICReceiveByte();
       IICAck();
       }
     *DataBuff=IICReceiveByte();        //read last byte data
     IICNoAck();
     errorflag=0;
     break;
     }
  }
IICStop();
if(!(ControlByte&0x01))
  {
  Delay24c(255);
  Delay24c(255);
  Delay24c(255);
  Delay24c(255);
  }
return(errorflag);
}


/*****************以下是对IIC总线的操作子程序***/
/*****************启动总线**********************/
void IICStart(void)
{
SCL=0;                  //
SDA=1;
SCL=1;
_nop_();
_nop_();
_nop_();
SDA=0;
_nop_();
_nop_();
_nop_();
_nop_();
SCL=0;
SDA=1;                  //
}

/*****************停止IIC总线****************/
void IICStop(void)
{
SCL=0;
SDA=0;
SCL=1;
_nop_();
_nop_();
_nop_();
SDA=1;
_nop_();
_nop_();
_nop_();
SCL=0;
}

/**************检查应答位*******************/
bit IICRecAck(void)
{
SCL=0;
SDA=1;
SCL=1;
_nop_();
_nop_();
_nop_();
_nop_();
CY=SDA;                 //因为返回值总是放在CY中的
SCL=0;
return(CY);
}

/***************对IIC总线产生应答*******************/
void IICACK(void)
{
SDA=0;
SCL=1;
_nop_();
_nop_();
_nop_();
_nop_();
SCL=0;
_nop_();
SDA=1;
}

/*****************不对IIC总线产生应答***************/
void IICNoAck(void)
{
SDA=1;
SCL=1;
_nop_();
_nop_();
_nop_();
_nop_();
SCL=0;
}

/*******************向IIC总线写数据*********************/
void IICSendByte(unsigned char sendbyte)
{
unsigned char data j=8;
for(;j>0;j--)
   {
   SCL=0;
   sendbyte<<=1;        //无论C51怎样实现这个操作，始终会使CY=sendbyte^7;
   SDA=CY;
   SCL=1;
   }
SCL=0;
}

/**********************从IIC总线上读数据子程序**********/
unsigned char IICReceiveByte(void)
{
register receivebyte,i=8;
SCL=0;
while(i--)
   {
   SCL=1;
   receivebyte=(receivebyte<<1)|SDA;
   SCL=0;
   }
return(receivebyte);
}

/***************一个简单延时程序************************/
void Delay24c(unsigned char Delay24cCount)
{
while(Delay24cCount--);
}





/***************************
//lcd1602.h
***************************/
#define LCD_PORT P0
#define DISPLAYON 0x0c
#define DISPLAYOFF 0x08
#define INPUTMODE 0x06
#define DISPLAYCLR 0x01
#define RETURNHOME 0x02

sbit LCD_RS=P2^5;
sbit LCD_RW=P2^6;
sbit LCD_EN=P2^7;

void write_lcd_command(unsigned char);
void write_lcd_data(unsigned char);
void write_lcd_char(unsigned char x,bit y,unsigned char DATA);
void write_lcd_string(unsigned char x,unsigned char y,unsigned char *p);

void lcd_init();
void delay20MS();
bit read_busy();
void gotoxy(unsigned char x,bit y);
/***************************************************************/
void lcd_init()
{
        delay20MS();
        delay20MS();  
        write_lcd_command (DISPLAYCLR);//清屏
        while(read_busy());//读忙标志
        write_lcd_command (0x38);//8位数据发送模式
        while(read_busy());//读忙标志
        write_lcd_command (DISPLAYON);//0x0C
        while(read_busy());//读忙标志
        write_lcd_command (INPUTMODE);//input mode
        while(read_busy());//读忙标志
        write_lcd_command (0x80);//设置LCD开始显示地址
        while(read_busy());//读忙标志
        write_lcd_command (DISPLAYCLR);//清屏
}

void delay20MS()//延时时间有待调整
{
        unsigned char i,j;
        for(i = 0; i < 255; i++)
        {
                for(j = 0; j < 100; j++);
        }
}

void write_lcd_command(unsigned char command)
{
        LCD_PORT = command;
        LCD_RS = 0;
        LCD_RW = 0;
        LCD_EN = 1;
        LCD_EN = 0;
}

void write_lcd_data(unsigned char dat)
{
        LCD_PORT = dat;
        LCD_RS = 1;
        LCD_RW = 0;
        LCD_EN = 1;
        LCD_EN = 0;
}

void write_lcd_char(unsigned char x,bit y,unsigned char DAT)
{
        gotoxy( x, y);
        while(read_busy());//读忙标志
        write_lcd_data(DAT);       
}

void write_lcd_string(unsigned char x,unsigned char y,unsigned char *p)
{
        gotoxy( x, y);
        while (*p)
        {
                while(read_busy());//读忙标志
                write_lcd_data(*p);
                p++;
        }
}
  
bit read_busy()
{
        unsigned char readdata;
        LCD_PORT = 0xff;
        LCD_RS = 0;
        LCD_RW = 1;
        LCD_EN = 1;
        readdata = LCD_PORT;
        LCD_EN = 0;
        if (readdata >> 7)
                return (1);
        else
                return (0);
}

void gotoxy(unsigned char x,bit y)
{
        while(read_busy());//读忙标志
        if(y)
                write_lcd_command(0xc0 + x);//2 line
        else
                write_lcd_command(0x80 + x);//1 line
}

gzqaqa

既然LZ说得甘简单，何必要别人做呢，自己做自己赚50元，PS: 现在请民工一日都50元啦， -_#!

lin135

楼主可能我能帮你，我弟弟现在学单片机，学了半桶水，想接案子做，给他做我辅助他，做出来的东西不会有问题的，但你要担供电路板。
我本人搞的话2小时就搞好了

有需要的可联系：
电话：0755-27886129
手机：13510253005   
qq：307906592
邮箱：ling13510253005@163.com

kyughanum

阿莫一下子扣了400分！我都吓倒了！哈哈！
9楼的也能不能随便带带我啊？

lin135

我不知道怎么带，学单片机需要兴趣和主动。我弟弟就缺这2样，我从0学单片机不用4个月，因我特喜欢，现在我都敢说我是写单片机的高手了，哈哈

mikkkz

活该扣分!把搞电子的给砸到这价格!

flyingfish

lz的24xx怎么没配置上拉电阻啊，那是不能正常工作的。不要把硬件也想的太简单了啊，呵呵。

neutronlmk

学习型遥控已经有低成本现成的方案，像这种使用通用IC来做的方案成本太高，用来推广没市场！
用来DIY也不适合，因为这个学习的过程要么是直接存时间要么是解码后存码值，需要的是耐心+时间，如果是存码值的话就整理个资料都不止一天啦。

kyughanum

11楼我应该怎么和你联系呢？

ndust

记号

XUEPENGBIN

【16楼】 mzsd2007
积分：28
派别：
等级：------
来自：

  严重鄙视《16》楼
  看到他在好多帖子里边都发广告！建议站长想点办发。。。。。。。。。。。！

bluebaby

不知道楼主的目的，
如果楼主只是想要个学习型遥控器的话，花50块钱买个二手的掌上电脑，然后装个软件，功能比你自己做的这个强大很多。。。

443799600

估计又是一个毕业设计的课题。。。
PS：我关注楼主的-400多分。

czzhouyun

哈哈,怎么又负了3分了

cuibaojian

我也是搞单机的，我本人对汇编语言有点特长，而对C却不是那么的好用！

hsztc

积分在这不值钱，正的1000分跟负的1000分对我来说是一样的

windy__xp

【25楼】 myk123
积分：74
派别：
等级：------
来自：
要不 阿莫  设置一个 下载要消耗 积分的 那你就；。
------------------------------------------------

    这样做，就不是 ouravr 了。

limzhw

悲剧的楼主

qdshen

有汇编的例子：使用NEC的78FKB2 0503。
没法传附件。只好贴过来


$PROCESSOR(F050330)
$NODEBUGA
$KANJICODE SJIS
$TOL_INF 2FH,400H,0,0FFFFH
$DGS FIL_NAM, .file,   U, 0FFFEH, 2FH, 67H, 1, 0
$DGS AUX_FIL, REMOTE.s
$DGL 0,1
                ok        equ  00h        ;  ok           equ  00h
$DGL 0,2
                erflmd0low        equ  01h        ;  erflmd0low   equ  01h
$DGL 0,3
                erparam        equ  05h        ;  erparam      equ  05h
$DGL 0,4
                erwrprtct        equ  10h        ;  erwrprtct    equ  10h
$DGL 0,5
                ererase        equ  1ah        ;  ererase      equ  1ah
$DGL 0,6
                erblnkchk        equ  1bh        ;  erblnkchk    equ  1bh
$DGL 0,7
                ervrfy        equ  1bh        ;  ervrfy       equ  1bh
$DGL 0,8
                erwrite        equ  1ch        ;  erwrite      equ  1ch
$DGL 0,9
                ervrmrg12        equ  1dh        ;  ervrmrg12    equ  1dh
$DGL 0,10
                brkintproc        equ  1fh        ;  brkintproc   equ  1fh
$DGL 0,11
                erread        equ  20h        ;  erread       equ  20h
  
$DGL 0,13
FLASH_ENV        EQU        00H        ;FLASH_ENV                       EQU                00H                                          ; Initialization
$DGL 0,14
FLASH_BLOCK_ERASE        EQU        03H        ;FLASH_BLOCK_ERASE               EQU                03H                                          ; Block erase
$DGL 0,15
FLASH_WORD_WRITE        EQU        04H        ;FLASH_WORD_WRITE                EQU                04H                                          ; Word write
$DGL 0,16
FLASH_BLOCK_VERIFY        EQU        06H        ;FLASH_BLOCK_VERIFY              EQU                06H                                          ; Block verify
$DGL 0,17
FLASH_BLOCK_BLANKCHECK        EQU        08H        ;FLASH_BLOCK_BLANKCHECK          EQU                08H                                          ; Block blank check
$DGL 0,18
FLASH_GET_INF        EQU        09H        ;FLASH_GET_INF                   EQU                09H                                          ; Flash memory information read
$DGL 0,19
FLASH_SET_INF        EQU        0AH        ;FLASH_SET_INF                   EQU                0AH                                          ; Flash memory information setting
$DGL 0,20
FLASH_CHECK_FLMD        EQU        0EH        ;FLASH_CHECK_FLMD                EQU                0EH                                          ; Mode check
$DGL 0,21
FLASH_EEPROM_WRITE        EQU        17H        ;FLASH_EEPROM_WRITE              EQU                17H                                          ; EEPROM write
$DGL 0,22
FLASHFIRM_PARAMETER_ERROR        EQU        05H        ;FLASHFIRM_PARAMETER_ERROR       EQU                05H                                          ; Parameter error
$DGL 0,23
BANK_BLC_ERROR        EQU        0FFH        ;BANK_BLC_ERROR                  EQU                0FFH                                         ; Bank number error(BLOCK)
$DGL 0,24
BANK_ADDR_ERROR        EQU        0FFFFH        ;BANK_ADDR_ERROR                 EQU                0FFFFH                                       ; Bank number error(ADDRESS)
$DGL 0,25
                DSTACK        DSEG AT 0FB00H        ;    DSTACK DSEG AT 0FB00H
$DGL 0,26
stackdeep:        ds        99        ;stackdeep:                      ds  99                                                           ; STACK AREA
$DGL 0,27
stackpointer:        ds        1        ;stackpointer:                   ds  1

$DGL 0,29
EEPROMBuf:        ds        308        ;EEPROMBuf:                      ds  308
$DGL 0,30
b100EntryRAM:        ds        100        ;b100EntryRAM:                   ds  100                                          ; Entry RAM for flash firmware control
$DGL 0,31
DataBuffer:        ds        100        ;DataBuffer:                     ds  100                                                               ;write_data_len+1                                   ; Calculate internal buffer setting value using
$DGL 0,32
codetypedata:        ds        64        ;codetypedata:                   ds  64                                                           ;16泿詰闃幩
$DGL 0,33
codeflowbyte:        ds        88        ;codeflowbyte:                   ds  88                                                          ;湈婑棊?4岕戦憲渦弝(歜檸箤魷u弝媍10彉泿?渦墠晭紤閻庌槑藣幟)
$DGL 0,34
compressdatabyte:        ds        40        ;compressdatabyte:               ds  40                                                           ;橷枙泿瑣駵帄駰帹32岕渦弝

$DGL 0,36
variableseg        dseg        saddr        ;variableseg                     dseg   saddr
$DGL 0,37
pls_whole:        ds        2        ;pls_whole:                      ds   2
$DGL 0,38
pls_low:        ds        2        ;pls_low:                        ds   2
$DGL 0,39
pls_high:        ds        2        ;pls_high:                       ds   2
$DGL 0,40
new_pls_low:        ds        2        ;new_pls_low:                    ds   2
$DGL 0,41
new_pls_high:        ds        2        ;new_pls_high:                   ds   2
$DGL 0,42
old_pls_low:        ds        2        ;old_pls_low:                    ds   2
$DGL 0,43
old_pls_high:        ds        2        ;old_pls_high:                   ds   2
$DGL 0,44
endcode:        ds        2        ;endcode:                        ds   2
$DGL 0,45
tempaddress:        ds        2        ;tempaddress:                    ds   2
$DGL 0,46
WordAddr:                        ;WordAddr:                                                                                              ; Write data structure
$DGL 0,47
writeaddress:        ds        2        ;writeaddress:                   ds   2                                                                  ; Write address
$DGL 0,48
writebank:        ds        1        ;writebank:                      ds   1                                                                  ; Write Bank N
$DGL 0,49
                ds        1        ;                                ds   1
$DGL 0,50
keydowncounter:        ds        2        ;keydowncounter:                 ds   2
$DGL 0,51
delaycounter:        ds        2        ;delaycounter:                   ds   2
$DGL 0,52
data_end_offset:        ds        2        ;data_end_offset:                ds   2
$DGL 0,53
tEEPROM_BLOCK:        ds        2        ;tEEPROM_BLOCK:                  ds   2
$DGL 0,54
temp1:                ds        2        ;temp1:                          ds   2
$DGL 0,55
tempdata:        ds        2        ;tempdata:                       ds   2
$DGL 0,56
sum:                ds        2        ;sum:                            ds   2
$DGL 0,57
                keynumber:        ds     1        ;    keynumber:            ds     1   
$DGL 0,58
                codetypenumber:        ds     1        ;    codetypenumber:       ds     1
$DGL 0,59
                flowbitnumber:        ds     1        ;    flowbitnumber:        ds     1
$DGL 0,60
                keypressedcounter:        ds     1        ;    keypressedcounter:    ds     1
$DGL 0,61
                temporarycounter:        ds            1        ;    temporarycounter:                  ds            1
$DGL 0,62
                workcounter:        ds     1        ;    workcounter:          ds     1
$DGL 0,63
                tempcounter:        ds     1        ;    tempcounter:          ds     1
$DGL 0,64
                counter:        ds     1        ;    counter:              ds     1
$DGL 0,65
                temp:        ds     1        ;    temp:                 ds     1
$DGL 0,66
                currentkeyid:        ds     1        ;    currentkeyid:         ds     1
$DGL 0,67
                currentkeyidbak:        ds     1        ;    currentkeyidbak:      ds     1
$DGL 0,68
                lastkeyid:        ds     1        ;    lastkeyid:            ds     1
$DGL 0,69
                lastkeyidbak:        ds     1        ;    lastkeyidbak:         ds     1
$DGL 0,70
                keyscantime:        ds     1        ;                keyscantime:          ds     1
                                       
$DGL 0,72
                datanumber:        ds     1        ;          datanumber:           ds     1
$DGL 0,73
                tempdatanumber:        ds     1        ;    tempdatanumber:       ds     1
$DGL 0,74
                datalength:        ds     1        ;    datalength:           ds     1
$DGL 0,75
                conslength:        ds     1        ;    conslength:           ds     1
$DGL 0,76
                codelength:        ds     1        ;                codelength:           ds     1
$DGL 0,77
                lengthcounter:        ds     1        ;                lengthcounter:        ds     1
$DGL 0,78
                databuf_len:        ds     1        ;    databuf_len:          ds     1
$DGL 0,79
                write_data_len:        ds     1        ;    write_data_len:       ds     1
$DGL 0,80
                data_of_block:        ds     1        ;    data_of_block:        ds     1
$DGL 0,81
                writeflashlength:        ds     1        ;    writeflashlength:     ds     1
$DGL 0,82
                conscounter:        ds     1        ;    conscounter:          ds     1
$DGL 0,83
                codebuffer:        ds     1        ;    codebuffer:           ds     1
$DGL 0,84
                sendcodestate:        ds     1        ;    sendcodestate:        ds     1
$DGL 0,85
                intp_reg12:        ds     1        ;                intp_reg12:           ds     1
$DGL 0,86
                intp_reg3:        ds     1        ;                intp_reg3:            ds     1
$DGL 0,87
                curdevstate:        ds     1        ;                curdevstate:          ds     1
$DGL 0,88
                i:        ds     1        ;          i:                    ds     1
$DGL 0,89
                j:        ds     1        ;                j:                    ds     1
$DGL 0,90
                status:        ds     1        ;                status:               ds     1
$DGL 0,91
                h0counter:        ds     1        ;                h0counter:            ds     1
$DGL 0,92
                overflowtime:        ds     1        ;                overflowtime:         ds     1
$DGL 0,93
                intervaloverflow1:        ds     1        ;                intervaloverflow1:    ds     1
$DGL 0,94
                intervaloverflow2:        ds     1        ;                intervaloverflow2:    ds     1
$DGL 0,95
                intervaloverflow3:        ds     1        ;                intervaloverflow3:    ds     1
$DGL 0,96
                conscounter1:        ds     1        ;                conscounter1:         ds     1
$DGL 0,97
                conscounter2:        ds     1        ;                conscounter2:         ds     1
$DGL 0,98
                conscounter3:        ds     1        ;                conscounter3:         ds     1
$DGL 0,99
                sametime:        ds     1        ;                sametime:             ds     1
$DGL 0,100
                intervaltime:        ds     1        ;                intervaltime:         ds     1   
$DGL 0,101
                bseg                ;          bseg   
$DGL 0,102
                newkeypress        dbit        ;    newkeypress                  dbit            
$DGL 0,103
                nosendcode        dbit        ;    nosendcode                   dbit
$DGL 0,104
                key_press        dbit        ;    key_press                    dbit
$DGL 0,105
                keypro_end        dbit        ;    keypro_end                   dbit
$DGL 0,106
                learn_mode        dbit        ;    learn_mode                   dbit
$DGL 0,107
                learn_send        dbit        ;    learn_send                   dbit
$DGL 0,108
                switchkey        dbit        ;    switchkey                    dbit
$DGL 0,109
                enable_learn        dbit        ;    enable_learn                 dbit
$DGL 0,110
                same1        dbit        ;    same1                        dbit
$DGL 0,111
                same2        dbit        ;    same2                        dbit
$DGL 0,112
                plusflag        dbit        ;    plusflag                     dbit
$DGL 0,113
                subflag        dbit        ;    subflag                      dbit
$DGL 0,114
                endcycle        dbit        ;    endcycle                     dbit
$DGL 0,115
                nofirst_learn        dbit        ;    nofirst_learn                dbit
$DGL 0,116
                keyflag        dbit        ;    keyflag                      dbit
$DGL 0,117
                timerflag        dbit        ;    timerflag                    dbit
$DGL 0,118
                RC_6        dbit        ;    RC_6                         dbit
$DGL 0,119
                RC_6_pre        dbit        ;    RC_6_pre                     dbit
$DGL 0,120
                RC_5        dbit        ;    RC_5                         dbit
$DGL 0,121
                case1        dbit        ;    case1                        dbit
$DGL 0,122
                case2        dbit        ;    case2                        dbit
$DGL 0,123
                nofirsttime        dbit        ;    nofirsttime                  dbit
$DGL 0,124
                code429        dbit        ;    code429                      dbit
$DGL 0,125
                code345        dbit        ;    code345                      dbit
$DGL 0,126
                toggle_code        dbit        ;    toggle_code                  dbit
$DGL 0,127
                samestring        dbit        ;    samestring                   dbit
$DGL 0,128
v_reset                cseg        at        0000h        ;v_reset                cseg        at        0000h
$DGL 0,129
                dw        start        ;                        dw        start
$DGL 0,130
v_intp0                cseg        at  0006h        ;v_intp0   cseg  at  0006h
$DGL 0,131
                dw        keyintp        ;      dw  keyintp
$DGL 0,132
v_intp1                cseg        at  0008h        ;v_intp1   cseg  at  0008h
$DGL 0,133
                dw        keyintp        ;      dw  keyintp
$DGL 0,134
v_intp2                cseg        at  000ah        ;v_intp2   cseg  at  000ah
$DGL 0,135
                dw        keyintp        ;      dw  keyintp
$DGL 0,136
v_intp3                cseg        at  000ch        ;v_intp3   cseg  at  000ch
$DGL 0,137
                dw        keyintp        ;      dw  keyintp
$DGL 0,138
v_intp4                cseg        at  000eh        ;v_intp4   cseg  at  000eh
$DGL 0,139
                dw        keyintp        ;      dw  keyintp
$DGL 0,140
v_tmh0                cseg        at  001ch        ;v_tmh0    cseg  at  001ch
$DGL 0,141
                dw        inttmh0        ;      dw  inttmh0
$DGL 0,142
v_tm50                cseg        at  001eh        ;v_tm50    cseg  at  001eh
$DGL 0,143
                dw        interval        ;      dw  interval
$DGL 0,144
v_tm00                cseg        at  0022h        ;v_tm00    cseg  at  0022h
$DGL 0,145
                dw        inttm010        ;          dw   inttm010
$DGL 0,146
Opt                cseg        at  0080h        ;Opt              cseg  at  0080h
$DGL 0,147
                db        78H        ;          db   78H
$DGL 0,148
                db        00H        ;          db   00H
$DGL 0,149
                db        00H        ;          db   00H
$DGL 0,150
                db        00H        ;          db   00H
$DGL 0,151
                db        02H        ;          db   02H
$DGL 0,152
main                cseg        at 0190h        ;main                        cseg    at 0190h
$DGL 0,153
start:                                ;start:
$DGL 0,154
                di                ;  di
$DGL 0,155
                MOV        IMS,#0C8H        ;  IMS=#0C8H         
$DGL 0,156
                MOVW        AX,#stackpointer        ;  AX=#stackpointer
$DGL 0,157
                MOVW        SP,AX        ;  SP=AX
                 
$DGL 0,159
                MOV        PM0,#11111101B        ;  PM0=#11111101B
$DGL 0,160
                MOV        P0,#00000000B        ;  P0=#00000000B
$DGL 0,161
                MOV        ADPC,#00000100B        ;  ADPC=#00000100B
$DGL 0,162
                MOV        PM2,#11110000B        ;  PM2=#11110000B
$DGL 0,163
                MOV        P2,#00000000B        ;  P2=#00000000B
$DGL 0,164
                MOV        PM1,#00000000B        ;  PM1=#00000000B
$DGL 0,165
                MOV        P1,#10000000B        ;  P1=#10000000B
  
$DGL 0,167
                MOV        PM3,#11111111B        ;  PM3=#11111111B
$DGL 0,168
                MOV        P3,#00001111B        ;  P3=#00001111B
$DGL 0,169
                MOV        PU3,#00001111B        ;  PU3=#00001111B
  
$DGL 0,171
                MOV        PM6,#11111100B        ;  PM6=#11111100B
$DGL 0,172
                MOV        P6,#00000000B        ;  P6=#00000000B
  
$DGL 0,174
                MOV        PM12,#11111111B        ;  PM12=#11111111B
$DGL 0,175
                MOV        P12,#00000001B        ;  P12=#00000001B
$DGL 0,176
                MOV        PU12,#00000001B        ;  PU12=#00000001B     
$DGL 0,177
                MOV        OSCCTL,#01000000B        ;  OSCCTL=#01000000B
$DGL 0,178
                MOV        MOC,#00000000B        ;  MOC=#00000000B
$DGL 0,179
                clockwait:        ;  clockwait:
$DGL 0,180
                MOV        a,OSTC        ;           a=OSTC
$DGL 0,181
                cmp        a,#01fh        ;           cmp a,#01fh
$DGL 0,182
                bnz        $clockwait        ;           bnz $clockwait
$DGL 0,183
                set1        xsel        ;  set1 xsel
$DGL 0,184
                set1        mcm0        ;  set1 mcm0
$DGL 0,185
                clr1        lsrstop        ;  clr1 lsrstop
$DGL 0,186
                set1        rstop        ;  set1 rstop
$DGL 0,187
                MOV        pcc,#00000000B        ;  pcc=#00000000B
$DGL 0,188
                MOV        OSTS,#00000001B        ;  OSTS=#00000001B
  
$DGL 0,190
                MOV        TMHMD0,#01000000B        ;  TMHMD0=#01000000B
$DGL 0,191
                MOV        CMP00,#7        ;  CMP00=#7
  
$DGL 0,193
                MOV        TCL50,#06H        ;  TCL50=#06H
$DGL 0,194
                MOV        CR50,#243        ;  CR50=#243
$DGL 0,195
                MOV        TMC50,#00H        ;  TMC50=#00H
  
$DGL 0,197
                MOV        counter,#0        ;  counter=#0
$DGL 0,198
                set1        PM0.0        ;  set1 PM0.0
$DGL 0,199
                set1        PU0.0        ;  set1 PU0.0
$DGL 0,200
                MOV        TMC00,#00000000B        ;  TMC00=#00000000B
$DGL 0,201
                MOV        CRC00,#00000101B        ;  CRC00=#00000101B
$DGL 0,202
                clr1        TOC00.4        ;  clr1 TOC00.4
$DGL 0,203
                clr1        TOC00.1        ;  clr1 TOC00.1
$DGL 0,204
                clr1        TOE00        ;  clr1 TOE00
$DGL 0,205
                clr1        LVS00        ;  clr1 LVS00
$DGL 0,206
                clr1        LVR00        ;  clr1 LVR00
$DGL 0,207
                MOV        PRM00,#11110000B        ;  PRM00=#11110000B
  
$DGL 0,209
                clr1        tmif010        ;  clr1 tmif010
$DGL 0,210
                set1        tmmk010        ;  set1 tmmk010
  
$DGL 0,212
                MOV        WDTE,#0ACH        ;  WDTE=#0ACH
$DGL 0,213
                MOV        EGP,#00000000B        ;  EGP=#00000000B
$DGL 0,214
                MOV        EGN,#00111111B        ;  EGN=#00111111B
$DGL 0,215
                MOVW        IF0,#0000H        ;  IF0=#0000H
$DGL 0,216
                MOVW        IF1,#0000H        ;  IF1=#0000H
$DGL 0,217
                MOVW        MK0,#0FFFFH        ;  MK0=#0FFFFH
$DGL 0,218
                MOVW        MK1,#0FFFFH        ;  MK1=#0FFFFH
$DGL 0,219
                MOVW        PR0,#0FFFFH        ;  PR0=#0FFFFH
$DGL 0,220
                MOVW        PR1,#0FFFFH        ;  PR1=#0FFFFH
$DGL 0,221
                clr1        pmk0        ;  clr1 pmk0
$DGL 0,222
                clr1        pmk1        ;  clr1 pmk1
$DGL 0,223
                clr1        pmk2        ;  clr1 pmk2
$DGL 0,224
                clr1        pmk3        ;  clr1 pmk3
$DGL 0,225
                clr1        pmk4        ;  clr1 pmk4              
$DGL 0,226
                set1        tmmk50        ;  set1 tmmk50
$DGL 0,227
                clr1        tce50        ;  clr1 tce50
$DGL 0,228
                clr1        nosendcode        ;  clr1 nosendcode
$DGL 0,229
                clr1        key_press        ;  clr1 key_press
$DGL 0,230
                clr1        learn_mode        ;  clr1 learn_mode
$DGL 0,231
                clr1        enable_learn        ;  clr1 enable_learn
$DGL 0,232
                MOV        curdevstate,#0        ;  curdevstate=#0
$DGL 0,233
                MOV        overflowtime,#0        ;  overflowtime=#0
$DGL 0,234
                MOV        intervaloverflow1,#0        ;  intervaloverflow1=#0
$DGL 0,235
                MOV        intervaloverflow2,#0        ;        intervaloverflow2=#0
$DGL 0,236
                MOV        intervaloverflow3,#0        ;        intervaloverflow3=#0
$DGL 0,237
                MOV        conscounter1,#0        ;        conscounter1=#0
$DGL 0,238
                MOV        conscounter2,#0        ;        conscounter2=#0
$DGL 0,239
                MOV        conscounter3,#0        ;        conscounter3=#0
$DGL 0,240
                MOV        conscounter,#0        ;        conscounter=#0
$DGL 0,241
                MOV        intervaltime,#0        ;        intervaltime=#0
$DGL 0,242
                ei                ;  ei
  
$DGL 0,244
                MOVW        AX,#0FB00H        ;FOR(HL=#0FB00H;HL<=#0FEDFH;HL++)(AX)   
                MOVW        HL,AX
?L1:
                MOVW        AX,HL
                CMPW        AX,#0FEDFH
                BZ        $?L2
                BC        $?L2
                BR        ?L3
?L2:
$DGL 0,245
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
$DGL 0,246
                MOV        A,#00H        ;    [HL]=#00H(A)
                MOV        [HL],A
                MOVW        AX,HL
                INCW        AX
                MOVW        HL,AX
                BR        ?L1
$DGL 0,247
?L3:                                ;NEXT
$DGL 0,248
loop:                                ;loop:
$DGL 0,249
                call        !standby        ;     call !standby
$DGL 0,250
                CMP        a,#00h        ;     IF(a==#00h)
                BZ        $?L4
                BR        ?L5
?L4:
$DGL 0,251
                di                ;        di
$DGL 0,252
                MOV        PM0,#11111101B        ;        PM0=#11111101B
$DGL 0,253
                MOV        P0,#00000000B        ;        P0=#00000000B
$DGL 0,254
                MOV        ADPC,#00000100B        ;        ADPC=#00000100B
$DGL 0,255
                MOV        PM2,#11110000B        ;        PM2=#11110000B
$DGL 0,256
                MOV        P2,#00000000B        ;        P2=#00000000B
$DGL 0,257
                MOV        PM1,#00000000B        ;        PM1=#00000000B
$DGL 0,258
                MOV        P1,#10000000B        ;        P1=#10000000B
  
$DGL 0,260
                MOV        PM3,#11111111B        ;        PM3=#11111111B
$DGL 0,261
                MOV        P3,#00001111B        ;        P3=#00001111B
$DGL 0,262
                MOV        PU3,#00001111B        ;        PU3=#00001111B
  
$DGL 0,264
                MOV        PM6,#11111100B        ;        PM6=#11111100B
$DGL 0,265
                MOV        P6,#00000000B        ;        P6=#00000000B
  
$DGL 0,267
                MOV        PM12,#11111111B        ;        PM12=#11111111B
$DGL 0,268
                MOV        P12,#00000001B        ;        P12=#00000001B
$DGL 0,269
                MOV        PU12,#00000001B        ;        PU12=#00000001B
$DGL 0,270
                clr1        pmk0        ;        clr1 pmk0
$DGL 0,271
                clr1        pmk1        ;        clr1 pmk1
$DGL 0,272
                clr1        pmk2        ;        clr1 pmk2
$DGL 0,273
                clr1        pmk3        ;        clr1 pmk3
$DGL 0,274
                clr1        pmk4        ;        clr1 pmk4              
$DGL 0,275
                clr1        pif0        ;                          clr1 pif0
$DGL 0,276
                clr1        pif1        ;                                 clr1 pif1
$DGL 0,277
                clr1        pif2        ;                                 clr1 pif2
$DGL 0,278
                clr1        pif3        ;                           clr1 pif3
$DGL 0,279
                clr1        pif4        ;                           clr1 pif4        
$DGL 0,280
                set1        tmmk50        ;                           set1 tmmk50
$DGL 0,281
                clr1        tce50        ;        clr1 tce50
$DGL 0,282
                clr1        tmif50        ;        clr1 tmif50
$DGL 0,283
                set1        lsrstop        ;        set1 lsrstop
$DGL 0,284
                clr1        nosendcode        ;        clr1 nosendcode
$DGL 0,285
                clr1        learn_mode        ;        clr1 learn_mode
$DGL 0,286
                clr1        newkeypress        ;        clr1 newkeypress
$DGL 0,287
                clr1        keypro_end        ;        clr1 keypro_end
$DGL 0,288
                clr1        enable_learn        ;        clr1 enable_learn
$DGL 0,289
                MOV        overflowtime,#0        ;        overflowtime=#0
$DGL 0,290
                MOV        intervaloverflow1,#0        ;        intervaloverflow1=#0
$DGL 0,291
                MOV        intervaloverflow2,#0        ;        intervaloverflow2=#0
$DGL 0,292
                MOV        intervaloverflow3,#0        ;        intervaloverflow3=#0
$DGL 0,293
                MOV        conscounter1,#0        ;        conscounter1=#0
$DGL 0,294
                MOV        conscounter2,#0        ;        conscounter2=#0
$DGL 0,295
                MOV        conscounter3,#0        ;        conscounter3=#0
$DGL 0,296
                MOV        conscounter,#0        ;        conscounter=#0
$DGL 0,297
                MOV        intervaltime,#0        ;        intervaltime=#0
$DGL 0,298
                MOV        WDTE,#0ACH        ;        WDTE=#0ACH
        
$DGL 0,300
                ei                ;        ei
$DGL 0,301
                call        !waitt        ;        call !waitt
        
$DGL 0,303
                stop                ;        stop
$DGL 0,304
                call        !waitt        ;        call !waitt
$DGL 0,305
                MOV        WDTE,#0ACH        ;        WDTE=#0ACH
$DGL 0,306
                call        !waitt        ;        call !waitt
$DGL 0,307
?L5:                                ;      ENDIF
$DGL 0,308
                BF        keyflag,$?L6        ;      if_bit(keyflag)
$DGL 0,309
                clr1        keyflag        ;        clr1 keyflag
$DGL 0,310
                set1        pmk0        ;        set1 pmk0
$DGL 0,311
                set1        pmk1        ;  set1 pmk1
$DGL 0,312
                set1        pmk2        ;  set1 pmk2
$DGL 0,313
                set1        pmk3        ;  set1 pmk3
$DGL 0,314
                set1        pmk4        ;  set1 pmk4
$DGL 0,315
                clr1        pif0        ;        clr1 pif0
$DGL 0,316
                clr1        pif1        ;        clr1 pif1
$DGL 0,317
                clr1        pif2        ;        clr1 pif2
$DGL 0,318
                clr1        pif3        ;         clr1 pif3
$DGL 0,319
                clr1        pif4        ;         clr1 pif4
$DGL 0,320
                clr1        lsrstop        ;         clr1 lsrstop
$DGL 0,321
                MOV        keyscantime,#0        ;  keyscantime=#0
$DGL 0,322
                MOV        currentkeyidbak,#0        ;         currentkeyidbak=#0                          
$DGL 0,323
                call        !keyscansub        ;        call !keyscansub
$DGL 0,324
                clr1        tmmk50        ;  clr1 tmmk50
$DGL 0,325
                clr1        tmif50        ;        clr1 tmif50
$DGL 0,326
                set1        tce50        ;  set1 tce50
$DGL 0,327
?L6:                                ;    endif
$DGL 0,328
                BF        timerflag,$?L7        ;    if_bit(timerflag)
$DGL 0,329
                clr1        timerflag        ;      clr1 timerflag
$DGL 0,330
                MOVW        ax,delaycounter        ;if(delaycounter!=#0)(ax)
                CMPW        ax,#0
                BZ        $?L8
$DGL 0,331
                MOVW        ax,delaycounter        ;           ax=delaycounter
$DGL 0,332
                incw        ax        ;           incw ax
$DGL 0,333
                MOVW        delaycounter,ax        ;           delaycounter=ax
$DGL 0,334
                BF        learn_mode,$?L9        ;           if_bit(learn_mode)
$DGL 0,335
                call        !keyscansub1        ;              call !keyscansub1
$DGL 0,336
?L9:                                ;           endif
                BR        ?L10
$DGL 0,337
?L8:                                ;else
$DGL 0,338
                call        !keyscansub1        ;     call !keyscansub1
$DGL 0,339
?L10:                                ;endif
$DGL 0,340
?L7:                                ;endif

$DGL 0,342
                call        !keyprocess        ;        call !keyprocess
$DGL 0,343
                call        !sendcode        ;        call !sendcode
$DGL 0,344
                MOV        WDTE,#0ACH        ;     WDTE=#0ACH
$DGL 0,345
br                !loop                ;br !loop
$DGL 0,346
RSet:                                ;RSet:
$DGL 0,347
                di                ;        di
$DGL 0,348
                MOV        WDTE,#0ACH        ;  WDTE=#0ACH
$DGL 0,349
RSet1:                                ;RSet1:                                   
$DGL 0,350
                BR        !RSet1        ;  BR !RSet1   
$DGL 0,351
ret                                ;ret
$DGL 0,352
standby:                        ;standby:
$DGL 0,353
                MOV        a,#0        ;  a=#0
$DGL 0,354
                CMP        currentkeyid,#0        ;  if(currentkeyid!=#0)
                BZ        $?L11
$DGL 0,355
                MOV        a,#0fh        ;     a=#0fh
$DGL 0,356
                ret                ;     ret
$DGL 0,357
?L11:                                ;  endif
$DGL 0,358
                CMP        sendcodestate,#0        ;  if(sendcodestate!=#0)
                BZ        $?L12
$DGL 0,359
                MOV        a,#0fh        ;     a=#0fh
$DGL 0,360
                ret                ;     ret
$DGL 0,361
?L12:                                ;  endif
$DGL 0,362
ret                                ;ret

$DGL 0,364
keyintp:                        ;keyintp:
$DGL 0,365
                set1        keyflag        ;  set1 keyflag
$DGL 0,366
                reti                ;  reti
  
$DGL 0,368
inttm010:                        ;inttm010:
$DGL 0,369
                push        ax        ;      push ax
$DGL 0,370
                push        bc        ;      push bc
$DGL 0,371
                push        de        ;      push de
$DGL 0,372
                push        hl        ;      push hl
$DGL 0,373
                CMP        overflowtime,#0        ;      if(overflowtime!=#0)
                BZ        $?L13
$DGL 0,374
                CMP        intervaltime,#0        ;         if(intervaltime==#0)
                BNZ        $?L14
$DGL 0,375
                INC        intervaltime        ;           intervaltime++
$DGL 0,376
                MOV        a,counter        ;           conscounter1=counter(a)
                MOV        conscounter1,a
$DGL 0,377
                MOV        a,overflowtime        ;           intervaloverflow1=overflowtime(a)
                MOV        intervaloverflow1,a
                BR        ?L15
$DGL 0,378
?L14:                                ;         else
$DGL 0,379
                CMP        intervaltime,#1        ;           if(intervaltime==#1)
                BNZ        $?L16
$DGL 0,380
                INC        intervaltime        ;             intervaltime++
$DGL 0,381
                MOV        a,counter        ;             conscounter2=counter(a)
                MOV        conscounter2,a
$DGL 0,382
                MOV        a,overflowtime        ;             intervaloverflow2=overflowtime(a)
                MOV        intervaloverflow2,a
                BR        ?L17
$DGL 0,383
?L16:                                ;           else
$DGL 0,384
                CMP        intervaltime,#2        ;             if(intervaltime==#2)
                BNZ        $?L18
$DGL 0,385
                INC        intervaltime        ;               intervaltime++
$DGL 0,386
                MOV        a,counter        ;               conscounter3=counter(a)
                MOV        conscounter3,a
$DGL 0,387
                MOV        a,overflowtime        ;               intervaloverflow3=overflowtime(a)
                MOV        intervaloverflow3,a
$DGL 0,388
?L18:                                ;             endif
$DGL 0,389
?L17:                                ;           endif
$DGL 0,390
?L15:                                ;         endif
$DGL 0,391
?L13:                                ;      endif
$DGL 0,392
                INC        counter        ;      counter++
$DGL 0,393
                clr1        OVF00        ;      clr1 OVF00
$DGL 0,394
                MOV        overflowtime,#0        ;      overflowtime=#0
$DGL 0,395
                clr1        lsrstop        ;      clr1 lsrstop
$DGL 0,396
                set1        tmmk50        ;      set1 tmmk50
$DGL 0,397
                clr1        tce50        ;      clr1 tce50
$DGL 0,398
                clr1        tmif50        ;      clr1 tmif50
      
$DGL 0,400
                MOVW        ax,cr010        ;       pls_whole=cr010(ax)
                MOVW        pls_whole,ax
$DGL 0,401
                MOV        lengthcounter,#0        ;       lengthcounter=#0
$DGL 0,402
                MOV        a,counter        ;       IF((counter>=#2)&&(counter<=#129))(a)
                CMP        a,#2
                BNC        $?L19
                BR        ?L21
?L19:
                MOV        a,counter
                CMP        a,#129
                BZ        $?L20
                BC        $?L20
                BR        ?L21
?L20:
$DGL 0,403
                MOV        a,counter        ;         a=counter
$DGL 0,404
                DEC        a        ;         a--
$DGL 0,405
                clr1        cy        ;         clr1 cy
$DGL 0,406
                rol        a,1        ;         rol a,1
$DGL 0,407
                and        a,#11111110b        ;         and a,#11111110b
$DGL 0,408
                DEC        a        ;         a--
$DGL 0,409
                MOV        b,a        ;         b=a
$DGL 0,410
                MOVW        hl,#EEPROMBuf        ;         hl=#EEPROMBuf
$DGL 0,411
                INCW        hl        ;         hl++
$DGL 0,412
                INCW        hl        ;         hl++
$DGL 0,413
                INCW        hl        ;         hl++
$DGL 0,414
                MOVW        ax,pls_whole        ;         ax=pls_whole
$DGL 0,415
                MOV        [hl+b],a        ;         [hl+b]=a
$DGL 0,416
                DEC        b        ;         b--
$DGL 0,417
                MOV        a,x        ;         [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,418
                clr1        tmifh0        ;         clr1 tmifh0
$DGL 0,419
                clr1        tmmkh0        ;         clr1 tmmkh0
$DGL 0,420
                set1        tmhe0        ;         set1 tmhe0
                BR        ?L22
$DGL 0,421
?L21:                                ;       ELSE
$DGL 0,422
                MOV        a,counter        ;         if(counter>=#130)(a)
                CMP        a,#130
                BC        $?L23
$DGL 0,423
                MOV        a,counter        ;           a=counter
$DGL 0,424
                subc        a,#128        ;           subc a,#128
$DGL 0,425
                DEC        a        ;           a--
$DGL 0,426
                clr1        cy        ;           clr1 cy
$DGL 0,427
                rol        a,1        ;           rol a,1
$DGL 0,428
                and        a,#11111110b        ;           and a,#11111110b
$DGL 0,429
                DEC        a        ;           a--
$DGL 0,430
                clr1        cy        ;           clr1 cy
$DGL 0,431
                MOV        b,a        ;           b=a
$DGL 0,432
                MOVW        hl,#EEPROMBuf        ;           hl=#EEPROMBuf
$DGL 0,433
                INCW        hl        ;           hl++
$DGL 0,434
                INCW        hl        ;           hl++
$DGL 0,435
                INCW        hl        ;           hl++
$DGL 0,436
                clr1        cy        ;           clr1 cy
$DGL 0,437
                MOV        a,l        ;           l+=#255,cy(a)
                ADDC        a,#255
                MOV        l,a
$DGL 0,438
                MOV        a,h        ;           h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,439
                INCW        hl        ;           hl++
$DGL 0,440
                MOVW        ax,pls_whole        ;           ax=pls_whole
$DGL 0,441
                MOV        [hl+b],a        ;           [hl+b]=a
$DGL 0,442
                DEC        b        ;           b--
$DGL 0,443
                MOV        a,x        ;           [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,444
                clr1        tmifh0        ;           clr1 tmifh0
$DGL 0,445
                clr1        tmmkh0        ;           clr1 tmmkh0
$DGL 0,446
                set1        tmhe0        ;           set1 tmhe0
$DGL 0,447
?L23:                                ;         endif
$DGL 0,448
?L22:                                ;       ENDIF
         
$DGL 0,450
                pop        hl        ;      pop hl
$DGL 0,451
                pop        de        ;      pop de
$DGL 0,452
                pop        bc        ;      pop bc
$DGL 0,453
                pop        ax        ;      pop ax
$DGL 0,454
reti                                ;reti
$DGL 0,455
inttmh0:                        ;inttmh0:
$DGL 0,456
                push        ax        ;  push ax
$DGL 0,457
                push        bc        ;  push bc
$DGL 0,458
                push        de        ;  push de
$DGL 0,459
                push        hl        ;  push hl
$DGL 0,460
                CMP        h0counter,#0        ;  if(h0counter!=#0)
                BZ        $?L24
$DGL 0,461
                MOV        a,h0counter        ;    a=h0counter
$DGL 0,462
                INC        a        ;    a++
$DGL 0,463
                MOV        h0counter,a        ;    h0counter=a
                BR        ?L25
$DGL 0,464
?L24:                                ;  else
$DGL 0,465
                BF        OVF00,$?L26        ;    if_bit(OVF00)
$DGL 0,466
                INC        overflowtime        ;     overflowtime++
$DGL 0,467
                nop                ;     nop
$DGL 0,468
                nop                ;     nop
$DGL 0,469
                nop                ;     nop
$DGL 0,470
                clr1        OVF00        ;     clr1 OVF00
$DGL 0,471
                CMP        overflowtime,#1        ;     if(overflowtime==#1)
                BNZ        $?L27
$DGL 0,472
                MOV        a,counter        ;       conscounter=counter(a)
                MOV        conscounter,a
$DGL 0,473
?L27:                                ;     endif
$DGL 0,474
?L26:                                ;    endif
$DGL 0,475
                INC        lengthcounter        ;    lengthcounter++
$DGL 0,476
                CMP        lengthcounter,#50        ;        if(lengthcounter>=#50)
                BC        $?L28
$DGL 0,477
                MOV        a,counter        ;            a=counter
$DGL 0,478
                BF        a.0,$?L29        ;            if(a.0)
$DGL 0,479
                MOV        counter,#0        ;               counter=#0
$DGL 0,480
                clr1        tmmk50        ;               clr1 tmmk50
$DGL 0,481
                set1        tce50        ;               set1 tce50
$DGL 0,482
                clr1        tmif50        ;               clr1 tmif50
$DGL 0,483
                clr1        tmifh0        ;               clr1 tmifh0
$DGL 0,484
                set1        tmmkh0        ;               set1 tmmkh0
$DGL 0,485
                clr1        tmhe0        ;               clr1 tmhe0
$DGL 0,486
                pop        hl        ;               pop hl
$DGL 0,487
                pop        de        ;               pop de
$DGL 0,488
                pop        bc        ;               pop bc
$DGL 0,489
                pop        ax        ;               pop ax
$DGL 0,490
                reti                ;               reti
$DGL 0,491
?L29:                                ;            endif
$DGL 0,492
                CMP        counter,#10        ;            if(counter<#10 || counter>=#200)
                BC        $?L30
                CMP        counter,#200
                BC        $?L31
?L30:
$DGL 0,493
                MOV        counter,#0        ;               counter=#0
$DGL 0,494
                clr1        tmmk50        ;               clr1 tmmk50
$DGL 0,495
                set1        tce50        ;               set1 tce50
$DGL 0,496
                clr1        tmif50        ;               clr1 tmif50
$DGL 0,497
                clr1        tmifh0        ;               clr1 tmifh0
$DGL 0,498
                set1        tmmkh0        ;               set1 tmmkh0
$DGL 0,499
                clr1        tmhe0        ;               clr1 tmhe0
$DGL 0,500
                pop        hl        ;               pop hl
$DGL 0,501
                pop        de        ;               pop de
$DGL 0,502
                pop        bc        ;               pop bc
$DGL 0,503
                pop        ax        ;               pop ax
$DGL 0,504
                reti                ;               reti
                BR        ?L32
$DGL 0,505
?L31:                                ;            else
$DGL 0,506
                MOV        lengthcounter,#0        ;               lengthcounter=#0
$DGL 0,507
                clr1        tmifh0        ;               clr1 tmifh0
$DGL 0,508
                set1        tmmkh0        ;               set1 tmmkh0
$DGL 0,509
                clr1        tmhe0        ;               clr1 tmhe0                        ;
$DGL 0,510
                clr1        tmif010        ;               clr1 tmif010
$DGL 0,511
                set1        tmmk010        ;               set1 tmmk010
$DGL 0,512
                MOV        tmc00,#00000000B        ;               tmc00=#00000000B
$DGL 0,513
                set1        key_press        ;               set1 key_press
$DGL 0,514
?L32:                                ;            endif
$DGL 0,515
?L28:                                ;        endif
$DGL 0,516
?L25:                                ;  endif
$DGL 0,517
                pop        hl        ;  pop hl
$DGL 0,518
                pop        de        ;  pop de
$DGL 0,519
                pop        bc        ;  pop bc
$DGL 0,520
                pop        ax        ;  pop ax
$DGL 0,521
reti                                ;reti

$DGL 0,523
RC_5sub:                        ;RC_5sub:
$DGL 0,524
                MOVW        hl,#EEPROMBuf        ;   hl=#EEPROMBuf
$DGL 0,525
                INCW        hl        ;   hl++
$DGL 0,526
                INCW        hl        ;   hl++
$DGL 0,527
                INCW        hl        ;   hl++
$DGL 0,528
                MOV        sametime,#0        ;   sametime=#0
$DGL 0,529
                MOV        i,#0        ;   i=#0
$DGL 0,530
RC_5_pro:                        ;RC_5_pro:   
$DGL 0,531
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,532
                MOV        x,a        ;   x=a
$DGL 0,533
                INCW        hl        ;   hl++
$DGL 0,534
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,535
                MOVW        tempdata,ax        ;   tempdata=ax
$DGL 0,536
                MOV        j,#0        ;   j=#0
$DGL 0,537
                MOVW        ax,tempdata        ;   if(tempdata<=#3556)(ax)
                CMPW        ax,#3556
                BZ        $$+4
                BNC        $?L33
$DGL 0,538
                br        !RC_5_pro0sub        ;      br !RC_5_pro0sub
$DGL 0,539
?L33:                                ;   endif
$DGL 0,540
RC_5_pro0:                        ;RC_5_pro0:   
$DGL 0,541
                MOVW        ax,tempdata        ;   ax=tempdata
$DGL 0,542
                clr1        cy        ;   clr1 cy
$DGL 0,543
                subw        ax,#3556        ;   subw ax,#3556
$DGL 0,544
                MOVW        tempdata,ax        ;   tempdata=ax
$DGL 0,545
                INC        j        ;   j++
$DGL 0,546
                cmpw        ax,#3556        ;   cmpw ax,#3556
$DGL 0,547
                bnc        $RC_5_pro0        ;   bnc $RC_5_pro0
$DGL 0,548
RC_5_pro0sub:                        ;RC_5_pro0sub:   
$DGL 0,549
                MOV        a,j        ;   a=j
$DGL 0,550
                                ;   switch(a)
$DGL 0,551
                CMP        a,#0        ;   case 0:
                BNZ        $?L34
                BR        ?L35
$DGL 0,552
?L34:                                ;   case 1:
                CMP        a,#1
                BNZ        $?L36
?L35:
                BR        ?L37
$DGL 0,553
?L36:                                ;   case 2:
                CMP        a,#2
                BNZ        $?L38
?L37:
$DGL 0,554
                MOVW        ax,tempdata        ;     if(tempdata>=#3056)(ax)
                CMPW        ax,#3056
                BC        $?L39
$DGL 0,555
                INC        sametime        ;        sametime++
                BR        ?L40
$DGL 0,556
?L39:                                ;     else
$DGL 0,557
                MOVW        ax,tempdata        ;       if(tempdata<=#500)(ax)
                CMPW        ax,#500
                BZ        $$+4
                BNC        $?L41
$DGL 0,558
                INC        sametime        ;        sametime++
$DGL 0,559
?L41:                                ;       endif
$DGL 0,560
?L40:                                ;     endif
$DGL 0,561
                BR        ?L42        ;   break
$DGL 0,562
?L38:                                ;   default:
$DGL 0,563
?L42:                                ;   ends
$DGL 0,564
                INCW        hl        ;   hl++
$DGL 0,565
                INC        i        ;   i++
   
$DGL 0,567
                MOV        a,counter        ;   a=counter
$DGL 0,568
                clr1        cy        ;   clr1 cy
$DGL 0,569
                subc        a,#1        ;   subc a,#1
$DGL 0,570
                MOV        temp,a        ;   temp=a
$DGL 0,571
                cmp        a,i        ;   cmp a,i
$DGL 0,572
                bnz        $RC_5_pro        ;   bnz $RC_5_pro
   
$DGL 0,574
                MOV        a,temp        ;   a=temp
$DGL 0,575
                clr1        cy        ;   clr1 cy
$DGL 0,576
                subc        a,#8        ;   subc a,#8
$DGL 0,577
                MOV        temp,a        ;   temp=a
   
$DGL 0,579
                MOV        a,sametime        ;   a=sametime
$DGL 0,580
                CMP        a,temp        ;   if(a>=temp)
                BC        $?L43
$DGL 0,581
                set1        RC_5        ;     set1 RC_5
$DGL 0,582
?L43:                                ;   endif
$DGL 0,583
                clr1        same1        ;   clr1 same1
$DGL 0,584
                clr1        same2        ;   clr1 same2
$DGL 0,585
                MOV        sametime,#0        ;   sametime=#0
$DGL 0,586
                clr1        RC_6_pre        ;   clr1 RC_6_pre
$DGL 0,587
ret                                ;ret

$DGL 0,589
RC_6sub:                        ;RC_6sub:
$DGL 0,590
                MOVW        hl,#EEPROMBuf        ;   hl=#EEPROMBuf
$DGL 0,591
                INCW        hl        ;   hl++
$DGL 0,592
                INCW        hl        ;   hl++
$DGL 0,593
                INCW        hl        ;   hl++
$DGL 0,594
                MOV        i,#0        ;   i=#0
   
$DGL 0,596
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,597
                MOV        x,a        ;   x=a
$DGL 0,598
                INCW        hl        ;   hl++
$DGL 0,599
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,600
                MOVW        tempdata,ax        ;   tempdata=ax
$DGL 0,601
RC_6_pro1:                        ;RC_6_pro1:
$DGL 0,602
                MOVW        ax,tempdata        ;   ax=tempdata
$DGL 0,603
                clr1        cy        ;   clr1 cy
$DGL 0,604
                subw        ax,#1778        ;   subw ax,#1778
$DGL 0,605
                MOVW        tempdata,ax        ;   tempdata=ax
$DGL 0,606
                INC        i        ;   i++
$DGL 0,607
                cmpw        ax,#1778        ;   cmpw ax,#1778
$DGL 0,608
                bnc        $RC_6_pro1        ;   bnc $RC_6_pro1
   
$DGL 0,610
                CMP        i,#5        ;   if(i==#5)
                BNZ        $?L44
$DGL 0,611
                MOVW        ax,tempdata        ;      if(tempdata>=#578)(ax)
                CMPW        ax,#578
                BC        $?L45
$DGL 0,612
                set1        same1        ;         set1 same1
$DGL 0,613
?L45:                                ;      endif
                BR        ?L46
$DGL 0,614
?L44:                                ;   else
$DGL 0,615
                CMP        i,#6        ;      if(i==#6)
                BNZ        $?L47
$DGL 0,616
                MOVW        ax,tempdata        ;        if(tempdata<=#1200)(ax)
                CMPW        ax,#1200
                BZ        $$+4
                BNC        $?L48
$DGL 0,617
                set1        same1        ;           set1 same1
$DGL 0,618
?L48:                                ;        endif
$DGL 0,619
?L47:                                ;      endif
$DGL 0,620
?L46:                                ;   endif
   
$DGL 0,622
                INCW        hl        ;   hl++
$DGL 0,623
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,624
                MOV        x,a        ;   x=a
$DGL 0,625
                INCW        hl        ;   hl++
$DGL 0,626
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,627
                MOVW        tempdata,ax        ;   tempdata=ax
$DGL 0,628
                MOV        i,#0        ;   i=#0
$DGL 0,629
RC_6_pro2:                        ;RC_6_pro2:
$DGL 0,630
                MOVW        ax,tempdata        ;   ax=tempdata
$DGL 0,631
                clr1        cy        ;   clr1 cy
$DGL 0,632
                subw        ax,#1778        ;   subw ax,#1778
$DGL 0,633
                MOVW        tempdata,ax        ;   tempdata=ax
$DGL 0,634
                INC        i        ;   i++
$DGL 0,635
                cmpw        ax,#1778        ;   cmpw ax,#1778
$DGL 0,636
                bnc        $RC_6_pro2        ;   bnc $RC_6_pro2
   
$DGL 0,638
                CMP        i,#1        ;   if(i==#1)
                BNZ        $?L49
$DGL 0,639
                MOVW        ax,tempdata        ;      if(tempdata>=#578)(ax)
                CMPW        ax,#578
                BC        $?L50
$DGL 0,640
                set1        same2        ;         set1 same2
$DGL 0,641
?L50:                                ;      endif
                BR        ?L51
$DGL 0,642
?L49:                                ;   else
$DGL 0,643
                CMP        i,#2        ;      if(i==#2)
                BNZ        $?L52
$DGL 0,644
                MOVW        ax,tempdata        ;        if(tempdata<=#1200)(ax)
                CMPW        ax,#1200
                BZ        $$+4
                BNC        $?L53
$DGL 0,645
                set1        same2        ;           set1 same2
$DGL 0,646
?L53:                                ;        endif
$DGL 0,647
?L52:                                ;      endif
$DGL 0,648
?L51:                                ;   endif
   
$DGL 0,650
                BF        same1,$?L54        ;   if_bit(same1)
$DGL 0,651
                BF        same2,$?L55        ;     if_bit(same2)
$DGL 0,652
                set1        RC_6_pre        ;       set1 RC_6_pre
$DGL 0,653
?L55:                                ;     endif
$DGL 0,654
?L54:                                ;   endif
   
$DGL 0,656
                clr1        same1        ;   clr1 same1
$DGL 0,657
                clr1        same2        ;   clr1 same2
   
$DGL 0,659
                MOVW        hl,#EEPROMBuf        ;   hl=#EEPROMBuf
$DGL 0,660
                INCW        hl        ;   hl++
$DGL 0,661
                INCW        hl        ;   hl++
$DGL 0,662
                INCW        hl        ;   hl++
$DGL 0,663
                clr1        cy        ;   clr1 cy
$DGL 0,664
                MOV        a,l        ;   l+=#4,cy(a)
                ADDC        a,#4
                MOV        l,a
$DGL 0,665
                MOV        a,h        ;   h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,666
                MOV        sametime,#0        ;   sametime=#0
$DGL 0,667
                MOV        i,#0        ;   i=#0
$DGL 0,668
RC_6_pro:                        ;RC_6_pro:   
$DGL 0,669
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,670
                MOV        x,a        ;   x=a
$DGL 0,671
                INCW        hl        ;   hl++
$DGL 0,672
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,673
                MOVW        tempdata,ax        ;   tempdata=ax
$DGL 0,674
                MOV        j,#0        ;   j=#0
$DGL 0,675
                MOVW        ax,tempdata        ;   if(tempdata<=#1778)(ax)
                CMPW        ax,#1778
                BZ        $$+4
                BNC        $?L56
$DGL 0,676
                br        !RC_6_pro0sub        ;      br !RC_6_pro0sub
$DGL 0,677
?L56:                                ;   endif
$DGL 0,678
RC_6_pro0:                        ;RC_6_pro0:   
$DGL 0,679
                MOVW        ax,tempdata        ;   ax=tempdata
$DGL 0,680
                clr1        cy        ;   clr1 cy
$DGL 0,681
                subw        ax,#1778        ;   subw ax,#1778
$DGL 0,682
                MOVW        tempdata,ax        ;   tempdata=ax
$DGL 0,683
                INC        j        ;   j++
$DGL 0,684
                cmpw        ax,#1778        ;   cmpw ax,#1778
$DGL 0,685
                bnc        $RC_6_pro0        ;   bnc $RC_6_pro0

$DGL 0,687
RC_6_pro0sub:                        ;RC_6_pro0sub:   
$DGL 0,688
                MOV        a,j        ;   a=j
$DGL 0,689
                                ;   switch(a)
$DGL 0,690
                CMP        a,#0        ;   case 0:
                BNZ        $?L57
                BR        ?L58
$DGL 0,691
?L57:                                ;   case 1:
                CMP        a,#1
                BNZ        $?L59
?L58:
                BR        ?L60
$DGL 0,692
?L59:                                ;   case 2:
                CMP        a,#2
                BNZ        $?L61
?L60:
                BR        ?L62
$DGL 0,693
?L61:                                ;   case 3:
                CMP        a,#3
                BNZ        $?L63
?L62:
$DGL 0,694
                MOVW        ax,tempdata        ;     if(tempdata>=#1478)(ax)
                CMPW        ax,#1478
                BC        $?L64
$DGL 0,695
                INC        sametime        ;        sametime++
                BR        ?L65
$DGL 0,696
?L64:                                ;     else
$DGL 0,697
                MOVW        ax,tempdata        ;       if(tempdata<=#300)(ax)
                CMPW        ax,#300
                BZ        $$+4
                BNC        $?L66
$DGL 0,698
                INC        sametime        ;        sametime++
$DGL 0,699
?L66:                                ;       endif
$DGL 0,700
?L65:                                ;     endif
$DGL 0,701
                BR        ?L67        ;   break
$DGL 0,702
?L63:                                ;   default:
$DGL 0,703
?L67:                                ;   ends
$DGL 0,704
                INCW        hl        ;   hl++
$DGL 0,705
                INC        i        ;   i++
   
$DGL 0,707
                MOV        a,counter        ;   a=counter
$DGL 0,708
                clr1        cy        ;   clr1 cy
$DGL 0,709
                subc        a,#3        ;   subc a,#3
$DGL 0,710
                MOV        temp,a        ;   temp=a
$DGL 0,711
                cmp        a,i        ;   cmp a,i
$DGL 0,712
                bnz        $RC_6_pro        ;   bnz $RC_6_pro
   
$DGL 0,714
                MOV        a,temp        ;   a=temp
$DGL 0,715
                clr1        cy        ;   clr1 cy
$DGL 0,716
                subc        a,#8        ;   subc a,#8
$DGL 0,717
                MOV        temp,a        ;   temp=a   
$DGL 0,718
                BF        RC_6_pre,$?L68        ;   if_bit(RC_6_pre)
$DGL 0,719
                MOV        a,sametime        ;     a=sametime
$DGL 0,720
                CMP        a,temp        ;     if(a>=temp)
                BC        $?L69
$DGL 0,721
                set1        RC_6        ;       set1 RC_6
$DGL 0,722
?L69:                                ;     endif
$DGL 0,723
?L68:                                ;   endif
$DGL 0,724
                clr1        RC_6_pre        ;   clr1 RC_6_pre
$DGL 0,725
                clr1        same1        ;   clr1 same1
$DGL 0,726
                clr1        same2        ;   clr1 same2
$DGL 0,727
                MOV        sametime,#0        ;   sametime=#0
$DGL 0,728
ret                                ;ret
$DGL 0,729
compressdata1:                        ;compressdata1:
$DGL 0,730
                call        !RC_6sub        ;    call !RC_6sub
$DGL 0,731
                call        !RC_5sub        ;    call !RC_5sub
$DGL 0,732
                call        !sub429        ;    call !sub429
$DGL 0,733
                call        !sub345        ;    call !sub345
$DGL 0,734
compressdata:                        ;compressdata:
$DGL 0,735
                MOV        workcounter,#0        ;    workcounter=#0
$DGL 0,736
data_process:                        ;data_process:
$DGL 0,737
                MOV        a,workcounter        ;    if(workcounter>=#63)(a)
                CMP        a,#63
                BC        $?L70
$DGL 0,738
                MOVW        hl,#EEPROMBuf        ;      hl=#EEPROMBuf
$DGL 0,739
                INCW        hl        ;      hl++
$DGL 0,740
                INCW        hl        ;      hl++
$DGL 0,741
                INCW        hl        ;      hl++
$DGL 0,742
                clr1        cy        ;      clr1 cy
$DGL 0,743
                MOV        a,l        ;      l+=#252,cy(a)
                ADDC        a,#252
                MOV        l,a
$DGL 0,744
                MOV        a,h        ;      h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,745
                MOV        a,workcounter        ;      a=workcounter
$DGL 0,746
                clr1        cy        ;      clr1 cy
$DGL 0,747
                subc        a,#63        ;      subc a,#63
$DGL 0,748
                clr1        cy        ;      clr1 cy
$DGL 0,749
                rol        a,1        ;      rol a,1
$DGL 0,750
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,751
                clr1        cy        ;      clr1 cy
$DGL 0,752
                rol        a,1        ;      rol a,1
$DGL 0,753
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,754
                MOV        b,a        ;      b=a
                BR        ?L71
$DGL 0,755
?L70:                                ;    else
$DGL 0,756
                MOV        a,workcounter        ;      a=workcounter
$DGL 0,757
                clr1        cy        ;      clr1 cy
$DGL 0,758
                rol        a,1        ;      rol a,1
$DGL 0,759
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,760
                clr1        cy        ;      clr1 cy
$DGL 0,761
                rol        a,1        ;      rol a,1
$DGL 0,762
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,763
                MOV        b,a        ;      b=a
$DGL 0,764
                MOVW        hl,#EEPROMBuf        ;      hl=#EEPROMBuf
$DGL 0,765
                INCW        hl        ;      hl++
$DGL 0,766
                INCW        hl        ;      hl++
$DGL 0,767
                INCW        hl        ;      hl++
$DGL 0,768
?L71:                                ;    endif
$DGL 0,769
                MOV        a,[hl+b]        ;      x=[hl+b](a)
                MOV        x,a
$DGL 0,770
                INCW        hl        ;      hl++
$DGL 0,771
                MOV        a,[hl+b]        ;      a=[hl+b]
$DGL 0,772
                INCW        hl        ;      hl++
$DGL 0,773
                MOVW        new_pls_low,ax        ;      new_pls_low=ax
$DGL 0,774
                MOV        a,[hl+b]        ;      x=[hl+b](a)
                MOV        x,a
$DGL 0,775
                INCW        hl        ;      hl++
$DGL 0,776
                MOV        a,[hl+b]        ;      a=[hl+b]
$DGL 0,777
                MOVW        new_pls_high,ax        ;      new_pls_high=ax
$DGL 0,778
                MOV        a,workcounter        ;    if(workcounter==#0)(a)
                CMP        a,#0
                BNZ        $?L72
$DGL 0,779
                MOV        codetypenumber,#0        ;      codetypenumber=#0
$DGL 0,780
                MOV        WDTE,#0ACH        ;      WDTE=#0ACH
$DGL 0,781
                call        !write_codetype        ;      call !write_codetype
$DGL 0,782
?L72:                                ;    endif
$DGL 0,783
                MOV        WDTE,#0ACH        ;      WDTE=#0ACH
$DGL 0,784
                call        !compare_datasub        ;      call !compare_datasub  
$DGL 0,785
                INC        workcounter        ;    workcounter++
$DGL 0,786
                MOV        a,counter        ;    a=counter
$DGL 0,787
                DEC        a        ;    a--
$DGL 0,788
                DEC        a        ;    a--
$DGL 0,789
                clr1        cy        ;    clr1 cy
$DGL 0,790
                ror        a,1        ;    ror a,1
$DGL 0,791
                and        a,#01111111b        ;    and a,#01111111b
$DGL 0,792
                cmp        a,workcounter        ;    cmp a,workcounter
$DGL 0,793
                bnz        $data_process        ;    bnz $data_process
   
$DGL 0,795
                MOV        flowbitnumber,#1        ;    flowbitnumber=#1
$DGL 0,796
                MOV        tempcounter,#2        ;    tempcounter=#2
$DGL 0,797
                CMP        codetypenumber,#2        ;    if(codetypenumber>=#2)
                BC        $?L73
$DGL 0,798
compress_pro:                        ;compress_pro:
$DGL 0,799
                MOV        a,tempcounter        ;       a=tempcounter
$DGL 0,800
                clr1        cy        ;       clr1 cy
$DGL 0,801
                rol        a,1        ;       rol a,1
$DGL 0,802
                and        a,#11111110b        ;       and a,#11111110b
$DGL 0,803
                MOV        tempcounter,a        ;       tempcounter=a
$DGL 0,804
                DEC        a        ;       a--
$DGL 0,805
                MOV        temp,a        ;       temp=a
$DGL 0,806
                MOV        a,flowbitnumber        ;       a=flowbitnumber
$DGL 0,807
                INC        a        ;       a++
$DGL 0,808
                MOV        flowbitnumber,a        ;       flowbitnumber=a
$DGL 0,809
                MOV        a,temp        ;       a=temp
$DGL 0,810
                cmp        a,codetypenumber        ;       cmp a,codetypenumber
$DGL 0,811
                bc        $compress_pro        ;       bc $compress_pro
$DGL 0,812
?L73:                                ;    endif
   
$DGL 0,814
                CMP        flowbitnumber,#1        ;    if(flowbitnumber==#1)
                BNZ        $?L74
$DGL 0,815
                MOV        flowbitnumber,#2        ;      flowbitnumber=#2
$DGL 0,816
?L74:                                ;    endif      
$DGL 0,817
                CMP        flowbitnumber,#2        ;    if(flowbitnumber==#2)
                BNZ        $?L75
$DGL 0,818
                MOVW        de,#codeflowbyte        ;      de=#codeflowbyte
$DGL 0,819
                MOVW        hl,#compressdatabyte        ;      hl=#compressdatabyte
$DGL 0,820
                MOV        tempcounter,#0        ;      tempcounter=#0
$DGL 0,821
                MOV        j,#0        ;      j=#0
$DGL 0,822
compress_pro1:                        ;compress_pro1:
$DGL 0,823
                MOV        WDTE,#0ACH        ;      WDTE=#0ACH
$DGL 0,824
                call        !write_compressdata1        ;      call !write_compressdata1
$DGL 0,825
                INCW        hl        ;      hl++
$DGL 0,826
                INCW        de        ;      de++
$DGL 0,827
                INC        tempcounter        ;      tempcounter++
      
$DGL 0,829
                MOV        a,counter        ;      a=counter
$DGL 0,830
                DEC        a        ;      a--
$DGL 0,831
                DEC        a        ;      a--
$DGL 0,832
                MOV        i,a        ;      i=a
$DGL 0,833
                clr1        cy        ;      clr1 cy
$DGL 0,834
                ror        a,1        ;      ror a,1
$DGL 0,835
                and        a,#01111111b        ;      and a,#01111111b
$DGL 0,836
                clr1        cy        ;      clr1 cy
$DGL 0,837
                ror        a,1        ;      ror a,1
$DGL 0,838
                and        a,#01111111b        ;      and a,#01111111b
$DGL 0,839
                clr1        cy        ;      clr1 cy
$DGL 0,840
                ror        a,1        ;      ror a,1
$DGL 0,841
                and        a,#01111111b        ;      and a,#01111111b
$DGL 0,842
                and        a,#00011111b        ;      and a,#00011111b
$DGL 0,843
                MOV        temp,a        ;      temp=a
$DGL 0,844
                clr1        cy        ;      clr1 cy
$DGL 0,845
                rol        a,1        ;      rol a,1
$DGL 0,846
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,847
                clr1        cy        ;      clr1 cy
$DGL 0,848
                rol        a,1        ;      rol a,1
$DGL 0,849
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,850
                clr1        cy        ;      clr1 cy
$DGL 0,851
                rol        a,1        ;      rol a,1
$DGL 0,852
                and        a,#11111000b        ;      and a,#11111000b
$DGL 0,853
                MOV        x,a        ;      x=a
$DGL 0,854
                clr1        cy        ;      clr1 cy
$DGL 0,855
                MOV        a,i        ;      a=i
$DGL 0,856
                subc        a,x        ;      subc a,x
$DGL 0,857
                CMP        a,#0        ;      if(a!=#0)
                BZ        $?L76
$DGL 0,858
                MOV        a,temp        ;         a=temp
$DGL 0,859
                INC        a        ;         a++
$DGL 0,860
                MOV        temp,a        ;         temp=a
$DGL 0,861
?L76:                                ;      endif
$DGL 0,862
                MOV        a,temp        ;      a=temp
$DGL 0,863
                cmp        a,tempcounter        ;      cmp a,tempcounter
$DGL 0,864
                bnz        $compress_pro1        ;      bnz $compress_pro1
$DGL 0,865
?L75:                                ;    endif
   
$DGL 0,867
                CMP        flowbitnumber,#4        ;    if(flowbitnumber==#4)
                BNZ        $?L77
$DGL 0,868
                MOV        flowbitnumber,#3        ;       flowbitnumber=#3
$DGL 0,869
?L77:                                ;    endif
   
$DGL 0,871
                CMP        flowbitnumber,#3        ;    if(flowbitnumber==#3)
                BNZ        $?L78
$DGL 0,872
                MOVW        de,#codeflowbyte        ;        de=#codeflowbyte
$DGL 0,873
                MOVW        hl,#compressdatabyte        ;        hl=#compressdatabyte
$DGL 0,874
                MOV        tempcounter,#0        ;        tempcounter=#0
$DGL 0,875
                MOV        j,#0        ;        j=#0
$DGL 0,876
compress_pro2:                        ;compress_pro2:
$DGL 0,877
                MOV        WDTE,#0ACH        ;        WDTE=#0ACH
$DGL 0,878
                call        !write_compressdata2        ;        call !write_compressdata2
$DGL 0,879
                INCW        hl        ;        hl++
$DGL 0,880
                INCW        de        ;        de++
$DGL 0,881
                INC        tempcounter        ;        tempcounter++
        
$DGL 0,883
                MOV        a,counter        ;        a=counter
$DGL 0,884
                DEC        a        ;        a--
$DGL 0,885
                DEC        a        ;        a--
        
$DGL 0,887
                MOV        i,a        ;        i=a
$DGL 0,888
                clr1        cy        ;      clr1 cy
$DGL 0,889
                ror        a,1        ;      ror a,1
$DGL 0,890
                and        a,#01111111b        ;      and a,#01111111b
$DGL 0,891
                clr1        cy        ;      clr1 cy
$DGL 0,892
                ror        a,1        ;      ror a,1
$DGL 0,893
                and        a,#01111111b        ;      and a,#01111111b
$DGL 0,894
                and        a,#00111111b        ;      and a,#00111111b
$DGL 0,895
                MOV        temp,a        ;      temp=a
$DGL 0,896
                clr1        cy        ;      clr1 cy
$DGL 0,897
                rol        a,1        ;      rol a,1
$DGL 0,898
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,899
                clr1        cy        ;      clr1 cy
$DGL 0,900
                rol        a,1        ;      rol a,1
$DGL 0,901
                and        a,#11111100b        ;      and a,#11111100b
$DGL 0,902
                MOV        x,a        ;      x=a
$DGL 0,903
                clr1        cy        ;      clr1 cy
$DGL 0,904
                MOV        a,i        ;      a=i
$DGL 0,905
                subc        a,x        ;      subc a,x
$DGL 0,906
                CMP        a,#0        ;      if(a!=#0)
                BZ        $?L79
$DGL 0,907
                MOV        a,temp        ;         a=temp
$DGL 0,908
                INC        a        ;         a++
$DGL 0,909
                MOV        temp,a        ;         temp=a
$DGL 0,910
?L79:                                ;      endif
$DGL 0,911
                MOV        a,temp        ;      a=temp
$DGL 0,912
                cmp        a,tempcounter        ;        cmp a,tempcounter
$DGL 0,913
                bnz        $compress_pro2        ;        bnz $compress_pro2
$DGL 0,914
?L78:                                ;    endif
$DGL 0,915
ret                                ;ret

$DGL 0,917
write_codetype:                        ;write_codetype:
$DGL 0,918
                MOV        a,codetypenumber        ;      a=codetypenumber
$DGL 0,919
                clr1        cy        ;      clr1 cy
$DGL 0,920
                rol        a,1        ;      rol a,1
$DGL 0,921
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,922
                clr1        cy        ;      clr1 cy
$DGL 0,923
                rol        a,1        ;      rol a,1
$DGL 0,924
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,925
                MOV        b,a        ;      b=a
$DGL 0,926
                MOVW        ax,new_pls_low        ;      ax=new_pls_low
$DGL 0,927
                MOV        c,a        ;      c=a
$DGL 0,928
                MOVW        hl,#codetypedata        ;      hl=#codetypedata
$DGL 0,929
                MOV        a,x        ;      [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,930
                INCW        hl        ;      hl++
$DGL 0,931
                MOV        a,c        ;      [hl+b]=c(a)
                MOV        [hl+b],a
$DGL 0,932
                INCW        hl        ;      hl++
$DGL 0,933
                MOVW        ax,new_pls_high        ;      ax=new_pls_high
$DGL 0,934
                MOV        c,a        ;      c=a
$DGL 0,935
                MOV        a,x        ;      [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,936
                INCW        hl        ;      hl++
$DGL 0,937
                MOV        a,c        ;      [hl+b]=c(a)
                MOV        [hl+b],a
$DGL 0,938
ret                                ;ret

$DGL 0,940
write_compressdata1:                ;write_compressdata1:
$DGL 0,941
                MOV        a,counter        ;      a=counter
$DGL 0,942
                DEC        a        ;      a--
$DGL 0,943
                DEC        a        ;      a--
$DGL 0,944
                clr1        cy        ;      clr1 cy
$DGL 0,945
                ror        a,1        ;      ror a,1
$DGL 0,946
                and        a,#01111111b        ;      and a,#01111111b
$DGL 0,947
                MOV        temp,a        ;      temp=a
      
$DGL 0,949
                MOV        a,#0        ;      [hl]=#0(a)
                MOV        [hl],a
$DGL 0,950
                MOV        a,[de]        ;      a=[de]
$DGL 0,951
                xor        a,[hl]        ;      xor a,[hl]
$DGL 0,952
                MOV        [hl],a        ;      [hl]=a
$DGL 0,953
                INC        j        ;      j++
$DGL 0,954
                MOV        a,j        ;      if(j==temp)(a)
                CMP        a,temp
                BNZ        $?L80
$DGL 0,955
                ret                ;        ret
$DGL 0,956
?L80:                                ;      endif
            
$DGL 0,958
                INCW        de        ;      de++
$DGL 0,959
                MOV        a,[de]        ;      a=[de]
$DGL 0,960
                clr1        cy        ;      clr1 cy
$DGL 0,961
                rol        a,1        ;      rol a,1
$DGL 0,962
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,963
                clr1        cy        ;      clr1 cy
$DGL 0,964
                rol        a,1        ;      rol a,1
$DGL 0,965
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,966
                xor        a,[hl]        ;      xor a,[hl]
$DGL 0,967
                MOV        [hl],a        ;      [hl]=a
$DGL 0,968
                INC        j        ;      j++
$DGL 0,969
                MOV        a,j        ;      if(j==temp)(a)
                CMP        a,temp
                BNZ        $?L81
$DGL 0,970
                ret                ;        ret
$DGL 0,971
?L81:                                ;      endif
      
$DGL 0,973
                INCW        de        ;      de++
$DGL 0,974
                MOV        a,[de]        ;      a=[de]
$DGL 0,975
                clr1        cy        ;      clr1 cy
$DGL 0,976
                rol        a,1        ;      rol a,1
$DGL 0,977
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,978
                clr1        cy        ;      clr1 cy
$DGL 0,979
                rol        a,1        ;      rol a,1
$DGL 0,980
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,981
                clr1        cy        ;      clr1 cy
$DGL 0,982
                rol        a,1        ;      rol a,1
$DGL 0,983
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,984
                clr1        cy        ;      clr1 cy
$DGL 0,985
                rol        a,1        ;      rol a,1
$DGL 0,986
                and        a,#11110000b        ;      and a,#11110000b
$DGL 0,987
                xor        a,[hl]        ;      xor a,[hl]
$DGL 0,988
                MOV        [hl],a        ;      [hl]=a
$DGL 0,989
                INC        j        ;      j++
$DGL 0,990
                MOV        a,j        ;      if(j==temp)(a)
                CMP        a,temp
                BNZ        $?L82
$DGL 0,991
                ret                ;        ret
$DGL 0,992
?L82:                                ;      endif
      
$DGL 0,994
                INCW        de        ;      de++
$DGL 0,995
                MOV        a,[de]        ;      a=[de]
$DGL 0,996
                clr1        cy        ;      clr1 cy
$DGL 0,997
                rol        a,1        ;      rol a,1
$DGL 0,998
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,999
                clr1        cy        ;      clr1 cy
$DGL 0,1000
                rol        a,1        ;      rol a,1
$DGL 0,1001
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,1002
                clr1        cy        ;      clr1 cy
$DGL 0,1003
                rol        a,1        ;      rol a,1
$DGL 0,1004
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,1005
                clr1        cy        ;      clr1 cy
$DGL 0,1006
                rol        a,1        ;      rol a,1
$DGL 0,1007
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,1008
                clr1        cy        ;      clr1 cy
$DGL 0,1009
                rol        a,1        ;      rol a,1
$DGL 0,1010
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,1011
                clr1        cy        ;      clr1 cy
$DGL 0,1012
                rol        a,1        ;      rol a,1
$DGL 0,1013
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,1014
                xor        a,[hl]        ;      xor a,[hl]
$DGL 0,1015
                MOV        [hl],a        ;      [hl]=a
$DGL 0,1016
                INC        j        ;      j++
$DGL 0,1017
                MOV        a,j        ;      if(j==temp)(a)
                CMP        a,temp
                BNZ        $?L83
$DGL 0,1018
                ret                ;        ret
$DGL 0,1019
?L83:                                ;      endif
$DGL 0,1020
ret                                ;ret

$DGL 0,1022
write_compressdata2:                ;write_compressdata2:
$DGL 0,1023
                MOV        a,counter        ;      a=counter
$DGL 0,1024
                DEC        a        ;      a--
$DGL 0,1025
                DEC        a        ;      a--
$DGL 0,1026
                clr1        cy        ;      clr1 cy
$DGL 0,1027
                ror        a,1        ;      ror a,1
$DGL 0,1028
                and        a,#01111111b        ;      and a,#01111111b
$DGL 0,1029
                MOV        temp,a        ;      temp=a
      
$DGL 0,1031
                MOV        a,#0        ;      [hl]=#0(a)
                MOV        [hl],a
$DGL 0,1032
                MOV        a,[de]        ;      a=[de]
$DGL 0,1033
                xor        a,[hl]        ;      xor a,[hl]
$DGL 0,1034
                MOV        [hl],a        ;      [hl]=a
$DGL 0,1035
                INC        j        ;      j++
$DGL 0,1036
                MOV        a,j        ;      if(j==temp)(a)
                CMP        a,temp
                BNZ        $?L84
$DGL 0,1037
                ret                ;        ret
$DGL 0,1038
?L84:                                ;      endif
            
$DGL 0,1040
                INCW        de        ;      de++
$DGL 0,1041
                MOV        a,[de]        ;      a=[de]
$DGL 0,1042
                clr1        cy        ;      clr1 cy
$DGL 0,1043
                rol        a,1        ;      rol a,1
$DGL 0,1044
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,1045
                clr1        cy        ;      clr1 cy
$DGL 0,1046
                rol        a,1        ;      rol a,1
$DGL 0,1047
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,1048
                clr1        cy        ;      clr1 cy
$DGL 0,1049
                rol        a,1        ;      rol a,1
$DGL 0,1050
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,1051
                clr1        cy        ;      clr1 cy
$DGL 0,1052
                rol        a,1        ;      rol a,1
$DGL 0,1053
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,1054
                xor        a,[hl]        ;      xor a,[hl]
$DGL 0,1055
                MOV        [hl],a        ;      [hl]=a
$DGL 0,1056
                INC        j        ;      j++
$DGL 0,1057
                MOV        a,j        ;      if(j==temp)(a)
                CMP        a,temp
                BNZ        $?L85
$DGL 0,1058
                ret                ;        ret
$DGL 0,1059
?L85:                                ;      endif
$DGL 0,1060
ret                                ;ret

$DGL 0,1062
twobyte_subtract:                ;twobyte_subtract:
$DGL 0,1063
                push        bc        ;   push bc
$DGL 0,1064
                push        de        ;   push de
$DGL 0,1065
                MOVW        de,ax        ;   de=ax
$DGL 0,1066
                MOV        a,x        ;   a=x
$DGL 0,1067
                clr1        cy        ;   clr1 cy
$DGL 0,1068
                subc        a,c        ;   subc a,c
$DGL 0,1069
                MOV        x,a        ;   x=a
$DGL 0,1070
                MOV        a,d        ;   a=d
$DGL 0,1071
                subc        a,b        ;   subc a,b
$DGL 0,1072
                pop        de        ;   pop de
$DGL 0,1073
                pop        bc        ;   pop bc
$DGL 0,1074
ret                                ;ret

$DGL 0,1076
compare_datasub:                ;compare_datasub:
$DGL 0,1077
                MOV        i,#0        ;      i=#0
$DGL 0,1078
compare1:                        ;compare1:
$DGL 0,1079
                MOVW        hl,#codetypedata        ;      hl=#codetypedata
$DGL 0,1080
                MOV        a,i        ;      a=i
$DGL 0,1081
                clr1        cy        ;      clr1 cy
$DGL 0,1082
                rol        a,1        ;      rol a,1
$DGL 0,1083
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,1084
                clr1        cy        ;      clr1 cy
$DGL 0,1085
                rol        a,1        ;      rol a,1
$DGL 0,1086
                and        a,#11111100b        ;      and a,#11111100b
$DGL 0,1087
                MOV        b,a        ;      b=a
$DGL 0,1088
                MOV        a,[hl+b]        ;      x=[hl+b](a)
                MOV        x,a
$DGL 0,1089
                INCW        hl        ;      hl++
$DGL 0,1090
                MOV        a,[hl+b]        ;      a=[hl+b]
$DGL 0,1091
                MOVW        old_pls_low,ax        ;      old_pls_low=ax
$DGL 0,1092
                INCW        hl        ;      hl++
$DGL 0,1093
                MOV        a,[hl+b]        ;      x=[hl+b](a)
                MOV        x,a
$DGL 0,1094
                INCW        hl        ;      hl++
$DGL 0,1095
                MOV        a,[hl+b]        ;      a=[hl+b]
$DGL 0,1096
                MOVW        old_pls_high,ax        ;      old_pls_high=ax
$DGL 0,1097
                MOV        WDTE,#0ACH        ;      WDTE=#0ACH
$DGL 0,1098
                call        !compare2        ;      call !compare2
      
$DGL 0,1100
                BF        endcycle,$?L86        ;      if_bit(endcycle)
$DGL 0,1101
                clr1        endcycle        ;        clr1 endcycle
$DGL 0,1102
                ret                ;        ret
                BR        ?L87
$DGL 0,1103
?L86:                                ;      else
$DGL 0,1104
                INC        i        ;        i++
$DGL 0,1105
                MOV        a,codetypenumber        ;        a=codetypenumber
$DGL 0,1106
                INC        a        ;        a++
$DGL 0,1107
                cmp        a,i        ;        cmp a,i
$DGL 0,1108
                bnz        $compare1        ;        bnz $compare1
        
$DGL 0,1110
                INC        codetypenumber        ;        codetypenumber++
$DGL 0,1111
                MOV        WDTE,#0ACH        ;        WDTE=#0ACH
$DGL 0,1112
                call        !write_codetype        ;        call !write_codetype
$DGL 0,1113
                MOVW        hl,#codeflowbyte        ;        hl=#codeflowbyte
$DGL 0,1114
                MOV        a,workcounter        ;        b=workcounter(a)
                MOV        b,a
$DGL 0,1115
                MOV        a,codetypenumber        ;        [hl+b]=codetypenumber(a)
                MOV        [hl+b],a
$DGL 0,1116
?L87:                                ;      endif
$DGL 0,1117
ret                                ;ret

$DGL 0,1119
compare2:                        ;compare2:
$DGL 0,1120
                MOVW        ax,old_pls_low        ;      bc=old_pls_low(ax)
                MOVW        bc,ax
$DGL 0,1121
                MOVW        ax,new_pls_low        ;      ax=new_pls_low
$DGL 0,1122
                call        !twobyte_subtract        ;      call !twobyte_subtract
$DGL 0,1123
                BNC        $?L88        ;      if_bit(cy)
$DGL 0,1124
                MOVW        ax,new_pls_low        ;        bc=new_pls_low(ax)
                MOVW        bc,ax
$DGL 0,1125
                MOVW        ax,old_pls_low        ;        ax=old_pls_low
$DGL 0,1126
                call        !twobyte_subtract        ;        call !twobyte_subtract
$DGL 0,1127
?L88:                                ;      endif
      
$DGL 0,1129
                CMPW        ax,#1200        ;      if(ax<=#1200)
                BZ        $$+4
                BNC        $?L89
$DGL 0,1130
                set1        same1        ;        set1 same1
$DGL 0,1131
?L89:                                ;      endif
      
$DGL 0,1133
                MOVW        ax,old_pls_high        ;      bc=old_pls_high(ax)
                MOVW        bc,ax
$DGL 0,1134
                MOVW        ax,new_pls_high        ;      ax=new_pls_high
$DGL 0,1135
                call        !twobyte_subtract        ;      call !twobyte_subtract
$DGL 0,1136
                BNC        $?L90        ;      if_bit(cy)
$DGL 0,1137
                MOVW        ax,new_pls_high        ;        bc=new_pls_high(ax)
                MOVW        bc,ax
$DGL 0,1138
                MOVW        ax,old_pls_high        ;        ax=old_pls_high
$DGL 0,1139
                call        !twobyte_subtract        ;        call !twobyte_subtract
$DGL 0,1140
?L90:                                ;      endif
      
$DGL 0,1142
                CMPW        ax,#1200        ;      if(ax<=#1200)
                BZ        $$+4
                BNC        $?L91
$DGL 0,1143
                set1        same2        ;        set1 same2
$DGL 0,1144
?L91:                                ;      endif
      
$DGL 0,1146
                BF        same1,$?L92        ;      if_bit(same1)
$DGL 0,1147
                BF        same2,$?L93        ;        if_bit(same2)
$DGL 0,1148
                MOVW        hl,#codeflowbyte        ;          hl=#codeflowbyte
$DGL 0,1149
                MOV        a,workcounter        ;          b=workcounter(a)
                MOV        b,a
$DGL 0,1150
                MOV        a,i        ;          [hl+b]=i(a)
                MOV        [hl+b],a
         
$DGL 0,1152
                set1        endcycle        ;          set1 endcycle
$DGL 0,1153
                clr1        same1        ;          clr1 same1
$DGL 0,1154
                clr1        same2        ;          clr1 same2
$DGL 0,1155
?L93:                                ;        endif
$DGL 0,1156
?L92:                                ;      endif
$DGL 0,1157
                clr1        same1        ;      clr1 same1
$DGL 0,1158
                clr1        same2        ;      clr1 same2
$DGL 0,1159
ret                                ;ret

$DGL 0,1161
flagdata_conv:                        ;flagdata_conv:
$DGL 0,1162
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
$DGL 0,1163
                MOVW        de,#DataBuffer        ;    de=#DataBuffer
$DGL 0,1164
                BT        nofirsttime,$?L94        ;    if_bit(!nofirsttime)
$DGL 0,1165
                MOVW        hl,#DataBuffer        ;      hl=#DataBuffer
$DGL 0,1166
                MOV        i,#0        ;      for(i=#0;i<=#100;i++)
?L95:
                CMP        i,#100
                BZ        $$+4
                BNC        $?L96
$DGL 0,1167
                MOV        WDTE,#0ACH        ;         WDTE=#0ACH
$DGL 0,1168
                MOV        a,#0        ;         [hl]=#0(a)
                MOV        [hl],a
$DGL 0,1169
                INCW        hl        ;         hl++
                INC        i
                BR        ?L95
$DGL 0,1170
?L96:                                ;      next
                BR        ?L97
$DGL 0,1171
?L94:                                ;    else
$DGL 0,1172
                clr1        cy        ;      clr1 cy
$DGL 0,1173
                MOV        a,e        ;      e+=#50,cy(a)
                ADDC        a,#50
                MOV        e,a
$DGL 0,1174
                MOV        a,d        ;      d+=#0,cy(a)
                ADDC        a,#0
                MOV        d,a
$DGL 0,1175
?L97:                                ;    endif
$DGL 0,1176
                MOV        a,datalength        ;    a=datalength
$DGL 0,1177
                MOV        [de],a        ;    [de]=a
$DGL 0,1178
                MOV        a,counter        ;    a=counter
$DGL 0,1179
                DEC        a        ;    a--
$DGL 0,1180
                DEC        a        ;    a--
$DGL 0,1181
                clr1        cy        ;    clr1 cy
$DGL 0,1182
                ror        a,1        ;    ror a,1
$DGL 0,1183
                and        a,#01111111b        ;    and a,#01111111b
$DGL 0,1184
                INCW        de        ;    de++
$DGL 0,1185
                MOV        [de],a        ;    [de]=a
$DGL 0,1186
                INCW        de        ;    de++
$DGL 0,1187
                MOV        a,codetypenumber        ;    a=codetypenumber
$DGL 0,1188
                MOV        [de],a        ;    [de]=a                       ;旣岕峸廁曽渦,婁宒殠貝I晭簵幑泿?曽弾蹔C嫀?檸▽A戦媍晭瑥槢幠媍歜戦槑藭麥u墠晭紜c戦憲岕曽
   
$DGL 0,1190
                MOV        i,#0        ;    i=#0
$DGL 0,1191
transfer1:                        ;transfer1:
$DGL 0,1192
                INCW        de        ;    de++
$DGL 0,1193
                MOVW        hl,#codetypedata        ;    hl=#codetypedata
$DGL 0,1194
                MOV        a,i        ;    a=i
$DGL 0,1195
                clr1        cy        ;    clr1 cy
$DGL 0,1196
                rol        a,1        ;    rol a,1
$DGL 0,1197
                and        a,#11111110b        ;    and a,#11111110b
$DGL 0,1198
                rol        a,1        ;    rol a,1
$DGL 0,1199
                and        a,#11111100b        ;    and a,#11111100b
$DGL 0,1200
                MOV        b,a        ;    b=a
$DGL 0,1201
                MOV        a,[hl+b]        ;    a=[hl+b]
$DGL 0,1202
                MOV        [de],a        ;    [de]=a
$DGL 0,1203
                INCW        de        ;    de++
$DGL 0,1204
                INCW        hl        ;    hl++
$DGL 0,1205
                MOV        a,[hl+b]        ;    a=[hl+b]
$DGL 0,1206
                MOV        [de],a        ;    [de]=a
$DGL 0,1207
                INCW        de        ;    de++
$DGL 0,1208
                INCW        hl        ;    hl++
$DGL 0,1209
                MOV        a,[hl+b]        ;    a=[hl+b]
$DGL 0,1210
                MOV        [de],a        ;    [de]=a
$DGL 0,1211
                INCW        de        ;    de++
$DGL 0,1212
                INCW        hl        ;    hl++
$DGL 0,1213
                MOV        a,[hl+b]        ;    a=[hl+b]
$DGL 0,1214
                MOV        [de],a        ;    [de]=a
$DGL 0,1215
                MOV        a,codetypenumber        ;    a=codetypenumber
$DGL 0,1216
                INC        a        ;    a++
$DGL 0,1217
                MOV        temp,a        ;    temp=a
$DGL 0,1218
                INC        i        ;    i++
$DGL 0,1219
                MOV        a,i        ;    a=i
$DGL 0,1220
                cmp        a,temp        ;    cmp a,temp
$DGL 0,1221
                bnz        $transfer1        ;    bnz $transfer1
   
$DGL 0,1223
                MOV        a,flowbitnumber        ;    a=flowbitnumber
$DGL 0,1224
                CMP        a,#2        ;    if(a==#2)
                BNZ        $?L98
$DGL 0,1225
                MOV        a,counter        ;      a=counter
$DGL 0,1226
                DEC        a        ;      a--
$DGL 0,1227
                DEC        a        ;      a--
$DGL 0,1228
                clr1        cy        ;      clr1 cy
$DGL 0,1229
                ror        a,1        ;      ror a,1
$DGL 0,1230
                and        a,#01111111b        ;      and a,#01111111b
$DGL 0,1231
                BF        a.0,$?L99        ;      if_bit(a.0)
$DGL 0,1232
                set1        plusflag        ;         set1 plusflag
                BR        ?L100
$DGL 0,1233
?L99:                                ;      else
$DGL 0,1234
                BF        a.1,$?L101        ;         if_bit(a.1)
$DGL 0,1235
                set1        plusflag        ;           set1 plusflag
$DGL 0,1236
?L101:                                ;         endif
$DGL 0,1237
?L100:                                ;      endif
$DGL 0,1238
                clr1        cy        ;      clr1 cy
$DGL 0,1239
                ror        a,1        ;      ror a,1
$DGL 0,1240
                and        a,#01111111b        ;      and a,#01111111b
$DGL 0,1241
                clr1        cy        ;      clr1 cy
$DGL 0,1242
                ror        a,1        ;      ror a,1
$DGL 0,1243
                and        a,#00111111b        ;      and a,#00111111b
$DGL 0,1244
                BF        plusflag,$?L102        ;      if_bit(plusflag)
$DGL 0,1245
                clr1        plusflag        ;         clr1 plusflag
$DGL 0,1246
                INC        a        ;         a++
$DGL 0,1247
?L102:                                ;      endif
$DGL 0,1248
                MOV        tempcounter,a        ;      tempcounter=a
$DGL 0,1249
?L98:                                ;    endif
$DGL 0,1250
                MOV        a,flowbitnumber        ;    a=flowbitnumber
$DGL 0,1251
                CMP        a,#4        ;    if(a==#4)
                BNZ        $?L103
$DGL 0,1252
                DEC        a        ;      a--
$DGL 0,1253
                MOV        flowbitnumber,a        ;      flowbitnumber=a
$DGL 0,1254
?L103:                                ;    endif
$DGL 0,1255
                MOV        a,flowbitnumber        ;    a=flowbitnumber
$DGL 0,1256
                CMP        a,#3        ;    if(a==#3)
                BNZ        $?L104
$DGL 0,1257
                MOV        a,counter        ;      a=counter
$DGL 0,1258
                DEC        a        ;      a--
$DGL 0,1259
                DEC        a        ;      a--
$DGL 0,1260
                clr1        cy        ;      clr1 cy
$DGL 0,1261
                ror        a,1        ;      ror a,1
$DGL 0,1262
                and        a,#01111111b        ;      and a,#01111111b
$DGL 0,1263
                BF        a.0,$?L105        ;      if_bit(a.0)
$DGL 0,1264
                set1        plusflag        ;        set1 plusflag
$DGL 0,1265
?L105:                                ;      endif
$DGL 0,1266
                ror        a,1        ;      ror a,1
$DGL 0,1267
                and        a,#01111111b        ;      and a,#01111111b
$DGL 0,1268
                BF        plusflag,$?L106        ;      if_bit(plusflag)
$DGL 0,1269
                clr1        plusflag        ;        clr1 plusflag
$DGL 0,1270
                INC        a        ;        a++
$DGL 0,1271
?L106:                                ;      endif
$DGL 0,1272
                MOV        tempcounter,a        ;      tempcounter=a
$DGL 0,1273
?L104:                                ;    endif
$DGL 0,1274
                MOV        i,#0        ;      i=#0
$DGL 0,1275
                INCW        de        ;      de++
$DGL 0,1276
                MOV        a,#00h        ;      [de]=#00h(a)                      ;殠貞闃幩?弾蹗幩戦憲?弾蹧幀庘彉槑螌驉?
                MOV        [de],a
$DGL 0,1277
transfer2:                        ;transfer2:
$DGL 0,1278
                INCW        de        ;      de++
$DGL 0,1279
                MOV        a,i        ;      a=i
$DGL 0,1280
                MOV        b,a        ;      b=a
$DGL 0,1281
                MOVW        hl,#compressdatabyte        ;      hl=#compressdatabyte
$DGL 0,1282
                MOV        a,[hl+b]        ;      a=[hl+b]
$DGL 0,1283
                MOV        [de],a        ;      [de]=a
$DGL 0,1284
                INC        i        ;      i++
$DGL 0,1285
                MOV        a,tempcounter        ;      a=tempcounter
$DGL 0,1286
                cmp        a,i        ;      cmp a,i
$DGL 0,1287
                bnz        $transfer2        ;      bnz $transfer2
      
$DGL 0,1289
                INCW        de        ;      de++
$DGL 0,1290
                INCW        de        ;      de++
      
$DGL 0,1292
                MOV        a,counter        ;      a=counter
$DGL 0,1293
                DEC        a        ;      a--
$DGL 0,1294
                clr1        cy        ;      clr1 cy
$DGL 0,1295
                rol        a,1        ;      rol a,1
$DGL 0,1296
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,1297
                DEC        a        ;      a--
$DGL 0,1298
                MOV        b,a        ;      b=a
$DGL 0,1299
                MOVW        hl,#EEPROMBuf        ;      hl=#EEPROMBuf
$DGL 0,1300
                INCW        hl        ;      hl++
$DGL 0,1301
                INCW        hl        ;      hl++
$DGL 0,1302
                INCW        hl        ;      hl++
$DGL 0,1303
                MOV        a,[hl+b]        ;      a=[hl+b]                        ;淎權妿蓨帳媍棊箾幜欵婸帋褧n3
$DGL 0,1304
                MOV        [de],a        ;      [de]=a
$DGL 0,1305
                DECW        de        ;      de--
$DGL 0,1306
                DEC        b        ;      b--
$DGL 0,1307
                MOV        a,[hl+b]        ;      a=[hl+b]
$DGL 0,1308
                MOV        [de],a        ;      [de]=a                          ;妿蓨帳檸蠌J枡歰檸▕鋽閒lash泿螊c?弾蹕幒宒殠貞jEEPROMBuf泿?
$DGL 0,1309
                INCW        de        ;      de++
$DGL 0,1310
                INCW        de        ;      de++
$DGL 0,1311
                BF        RC_5,$?L107        ;      if_bit(RC_5)
$DGL 0,1312
                MOV        a,#5        ;        [de]=#5(a)
                MOV        [de],a
$DGL 0,1313
?L107:                                ;      endif
$DGL 0,1314
                BF        RC_6,$?L108        ;      if_bit(RC_6)
$DGL 0,1315
                MOV        a,#6        ;        [de]=#6(a)
                MOV        [de],a
$DGL 0,1316
?L108:                                ;      endif
$DGL 0,1317
                BF        code429,$?L109        ;      if_bit(code429)
$DGL 0,1318
                MOV        a,#1        ;        [de]=#1(a)
                MOV        [de],a
$DGL 0,1319
?L109:                                ;      endif
$DGL 0,1320
                BF        code345,$?L110        ;      if_bit(code345)
$DGL 0,1321
                MOV        a,#2        ;        [de]=#2(a)
                MOV        [de],a
$DGL 0,1322
?L110:                                ;      endif
$DGL 0,1323
                INCW        de        ;      de++
$DGL 0,1324
                CMP        intervaloverflow1,#0        ;      if(intervaloverflow1!=#0)
                BZ        $?L111
$DGL 0,1325
                MOV        a,intervaloverflow1        ;         [de]=intervaloverflow1(a)
                MOV        [de],a
$DGL 0,1326
                INCW        de        ;         de++
$DGL 0,1327
                MOV        a,conscounter1        ;         [de]=conscounter1(a)
                MOV        [de],a
$DGL 0,1328
                INCW        de        ;         de++
$DGL 0,1329
                CMP        intervaloverflow2,#0        ;         if(intervaloverflow2!=#0)
                BZ        $?L112
$DGL 0,1330
                MOV        a,intervaloverflow2        ;            [de]=intervaloverflow2(a)
                MOV        [de],a
$DGL 0,1331
                INCW        de        ;            de++
$DGL 0,1332
                MOV        a,conscounter2        ;            [de]=conscounter2(a)
                MOV        [de],a
$DGL 0,1333
                INCW        de        ;            de++
$DGL 0,1334
                CMP        intervaloverflow3,#0        ;            if(intervaloverflow3!=#0)
                BZ        $?L113
$DGL 0,1335
                MOV        a,intervaloverflow3        ;              [de]=intervaloverflow3(a)
                MOV        [de],a
$DGL 0,1336
                INCW        de        ;              de++
$DGL 0,1337
                MOV        a,conscounter3        ;              [de]=conscounter3(a)
                MOV        [de],a
$DGL 0,1338
?L113:                                ;            endif
$DGL 0,1339
?L112:                                ;         endif
$DGL 0,1340
?L111:                                ;      endif
            
$DGL 0,1342
                MOV        a,codetypenumber        ;      a=codetypenumber
$DGL 0,1343
                INC        a        ;      a++
$DGL 0,1344
                clr1        cy        ;      clr1 cy
$DGL 0,1345
                rol        a,1        ;      rol a,1
$DGL 0,1346
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,1347
                clr1        cy        ;      clr1 cy
$DGL 0,1348
                rol        a,1        ;      rol a,1
$DGL 0,1349
                and        a,#11111100b        ;      and a,#11111100b
$DGL 0,1350
                INC        a        ;      a++
$DGL 0,1351
                INC        a        ;      a++
$DGL 0,1352
                INC        a        ;      a++
$DGL 0,1353
                MOV        temp,a        ;      temp=a
$DGL 0,1354
                MOV        a,tempcounter        ;      x=tempcounter(a)
                MOV        x,a
$DGL 0,1355
                clr1        cy        ;      clr1 cy
$DGL 0,1356
                MOV        a,temp        ;      a=temp
$DGL 0,1357
                addc        a,x        ;      addc a,x
$DGL 0,1358
                INC        a        ;      a++
$DGL 0,1359
                INC        a        ;      a++
$DGL 0,1360
                INC        a        ;      a++
$DGL 0,1361
                MOV        datalength,a        ;      datalength=a
$DGL 0,1362
                push        ax        ;      push ax
$DGL 0,1363
                MOVW        hl,#DataBuffer        ;      hl=#DataBuffer
$DGL 0,1364
                BF        nofirsttime,$?L114        ;      if_bit(nofirsttime)
$DGL 0,1365
                clr1        nofirsttime        ;        clr1 nofirsttime
$DGL 0,1366
                clr1        cy        ;        clr1 cy
$DGL 0,1367
                MOV        a,l        ;        l+=#50,cy(a)
                ADDC        a,#50
                MOV        l,a
$DGL 0,1368
                MOV        a,h        ;        h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,1369
?L114:                                ;      endif
$DGL 0,1370
                pop        ax        ;      pop ax
$DGL 0,1371
                MOV        [hl],a        ;      [hl]=a                ;廕泦?媍奀嫀?弾蹔鋵d殠?弾蹛I梀媍棊箾幜
$DGL 0,1372
ret                                ;ret

$DGL 0,1374
selfprogrampro1:                ;selfprogrampro1:            ;殠貦F極妿?妅泿??弾蹕c婁宒棊箾幜棊―ataBuffer
$DGL 0,1375
                MOVW        hl,#DataBuffer        ;   hl=#DataBuffer
$DGL 0,1376
                MOVW        de,#EEPROMBuf        ;   de=#EEPROMBuf
   
$DGL 0,1378
                MOV        a,datanumber        ;   a=datanumber
$DGL 0,1379
                CMP        a,#10        ;   if(a<=#10)
                BZ        $$+4
                BNC        $?L115
$DGL 0,1380
                MOVW        temp,#0        ;     temp=#0
$DGL 0,1381
                br        !writeflash        ;     br !writeflash
$DGL 0,1382
?L115:                                ;   endif
$DGL 0,1383
                MOV        a,datanumber        ;   a=datanumber
$DGL 0,1384
                MOVW        temp,#0        ;   temp=#0
$DGL 0,1385
                MOV        tempdatanumber,a        ;   tempdatanumber=a

$DGL 0,1387
data_scale:                        ;data_scale:
$DGL 0,1388
                MOV        a,tempdatanumber        ;   a=tempdatanumber
$DGL 0,1389
                clr1        cy        ;   clr1 cy
$DGL 0,1390
                subc        a,#10        ;   subc a,#10
$DGL 0,1391
                MOV        tempdatanumber,a        ;   tempdatanumber=a
$DGL 0,1392
                MOV        a,temp        ;   a=temp
$DGL 0,1393
                INC        a        ;   a++
$DGL 0,1394
                MOV        temp,a        ;   temp=a
$DGL 0,1395
                MOV        a,tempdatanumber        ;   a=tempdatanumber
$DGL 0,1396
                cmp        a,#10        ;   cmp a,#10
$DGL 0,1397
                bz        $writeflash        ;   bz $writeflash
$DGL 0,1398
                bnc        $data_scale        ;   bnc $data_scale
   
$DGL 0,1400
writeflash:                        ;writeflash:
$DGL 0,1401
                MOV        a,temp        ;   a=temp
$DGL 0,1402
                MOV        x,#10        ;   x=#10
$DGL 0,1403
                mulu        x        ;   mulu x
$DGL 0,1404
                MOV        a,datanumber        ;   a=datanumber
$DGL 0,1405
                clr1        cy        ;   clr1 cy
$DGL 0,1406
                subc        a,x        ;   subc a,x
$DGL 0,1407
                MOV        keynumber,a        ;   keynumber=a
$DGL 0,1408
                DEC        a        ;   a--
$DGL 0,1409
                MOV        x,#100        ;   x=#100
$DGL 0,1410
                mulu        x        ;   mulu x
$DGL 0,1411
                MOVW        tempaddress,ax        ;   tempaddress=ax

$DGL 0,1413
                MOV        WDTE,#0ACH        ;     WDTE=#0ACH
$DGL 0,1414
                push        psw        ;     push psw
$DGL 0,1415
                di                ;     di
$DGL 0,1416
                MOVW        ax,mk0        ;     ax=mk0
$DGL 0,1417
                push        ax        ;     push ax
$DGL 0,1418
                MOVW        mk0,#0ffffh        ;     mk0=#0ffffh
$DGL 0,1419
                MOVW        ax,mk1        ;     ax=mk1
$DGL 0,1420
                push        ax        ;     push ax
$DGL 0,1421
                MOVW        mk1,#0ffffh        ;     mk1=#0ffffh
$DGL 0,1422
                MOV        ADPC,#04h        ;     ADPC=#04h
$DGL 0,1423
                clr1        pm2.1        ;     clr1 pm2.1
$DGL 0,1424
                set1        p2.1        ;     set1 p2.1
     
$DGL 0,1426
                call        !_FlashStart        ;     call !_FlashStart
$DGL 0,1427
                MOVW        ax,#b100EntryRAM        ;     ax=#b100EntryRAM
$DGL 0,1428
                call        !_FlashEnv        ;     call !_FlashEnv
$DGL 0,1429
                call        !_CheckFLMD        ;     call !_CheckFLMD
$DGL 0,1430
                MOV        status,a        ;     status=a
$DGL 0,1431
                CMP        a,#0        ;     if(a!=#0)
                BZ        $?L116
$DGL 0,1432
                call        !selfprogerrmsg        ;        call !selfprogerrmsg
$DGL 0,1433
?L116:                                ;     endif
$DGL 0,1434
                call        !erase_common        ;     call !erase_common
$DGL 0,1435
                call        !_FlashEnd        ;     call !_FlashEnd
$DGL 0,1436
                clr1        p2.1        ;     clr1 p2.1
$DGL 0,1437
                pop        ax        ;        pop ax
$DGL 0,1438
                MOVW        mk1,ax        ;        mk1=ax
$DGL 0,1439
                pop        ax        ;        pop ax
$DGL 0,1440
                MOVW        mk0,ax        ;        mk0=ax
$DGL 0,1441
                pop        psw        ;        pop psw           ;晭諛g墂橀廕block30岼峇敇庘墡繆?檸覊儚槝幬嫀繕幉崫妅
         
$DGL 0,1443
                MOVW        ax,tEEPROM_BLOCK        ;     ax=tEEPROM_BLOCK     ;怚晭簭J婸擮恡庘媍曽弾蹕幒媂枎貗\岼峇敇庘愴
$DGL 0,1444
                MOVW        hl,ax        ;     hl=ax
$DGL 0,1445
                MOV        a,[hl]        ;     a=[hl]
$DGL 0,1446
                call        !BlockToAddress        ;     call !BlockToAddress
$DGL 0,1447
                MOVW        hl,ax        ;     hl=ax
$DGL 0,1448
                MOV        i,#0        ;     for(i=#0;i<#10;i++)
?L117:
                CMP        i,#10
                BNC        $?L118
$DGL 0,1449
                MOV        WDTE,#0ACH        ;        WDTE=#0ACH
$DGL 0,1450
                MOVW        de,#EEPROMBuf        ;        de=#EEPROMBuf
$DGL 0,1451
                MOV        j,#0        ;        for(j=#0;j<#100;j++)
?L119:
                CMP        j,#100
                BNC        $?L120
$DGL 0,1452
                MOV        a,[hl]        ;           a=[hl]
$DGL 0,1453
                MOV        [de],a        ;           [de]=a
$DGL 0,1454
                INCW        hl        ;           hl++
$DGL 0,1455
                INCW        de        ;           de++
                INC        j
                BR        ?L119
$DGL 0,1456
?L120:                                ;        next
        
$DGL 0,1458
                MOV        a,i        ;        a=i
$DGL 0,1459
                MOV        x,#100        ;        x=#100
$DGL 0,1460
                mulu        x        ;        mulu x
$DGL 0,1461
                addw        ax,#3800h        ;        addw ax,#3800h
        
$DGL 0,1463
                MOVW        writeaddress,ax        ;        writeaddress=ax
$DGL 0,1464
                MOV        writebank,#0        ;        writebank=#0
$DGL 0,1465
                MOV        writeflashlength,#25        ;        writeflashlength=#25
$DGL 0,1466
                push        hl        ;        push hl
$DGL 0,1467
                MOV        a,i        ;        a=i
$DGL 0,1468
                push        ax        ;        push ax                 ;廕hl,i曽泿硥B嶤擃悗矙幰墐檸覎駮幏歜
        
$DGL 0,1470
                MOV        WDTE,#0ACH        ;        WDTE=#0ACH
$DGL 0,1471
                push        psw        ;        push psw
$DGL 0,1472
                di                ;        di
$DGL 0,1473
                MOVW        ax,mk0        ;        ax=mk0
$DGL 0,1474
                push        ax        ;        push ax
$DGL 0,1475
                MOVW        mk0,#0ffffh        ;        mk0=#0ffffh
$DGL 0,1476
                MOVW        ax,mk1        ;        ax=mk1
$DGL 0,1477
                push        ax        ;        push ax
$DGL 0,1478
                MOVW        mk1,#0ffffh        ;        mk1=#0ffffh
$DGL 0,1479
                MOV        ADPC,#04h        ;        ADPC=#04h
$DGL 0,1480
                clr1        pm2.1        ;        clr1 pm2.1
$DGL 0,1481
                set1        p2.1        ;        set1 p2.1
        
$DGL 0,1483
                call        !_FlashStart        ;        call !_FlashStart
$DGL 0,1484
                MOVW        ax,#b100EntryRAM        ;        ax=#b100EntryRAM
$DGL 0,1485
                call        !_FlashEnv        ;        call !_FlashEnv
$DGL 0,1486
                call        !_CheckFLMD        ;        call !_CheckFLMD
$DGL 0,1487
                MOV        status,a        ;        status=a
$DGL 0,1488
                CMP        a,#0        ;        if(a!=#0)
                BZ        $?L121
$DGL 0,1489
                call        !selfprogerrmsg        ;           call !selfprogerrmsg
$DGL 0,1490
?L121:                                ;        endif
$DGL 0,1491
                MOVW        hl,#EEPROMBuf        ;        hl=#EEPROMBuf
$DGL 0,1492
                call        !flashwrite_sub        ;        call !flashwrite_sub
$DGL 0,1493
                call        !_FlashEnd        ;        call !_FlashEnd
$DGL 0,1494
                clr1        p2.1        ;        clr1 p2.1
$DGL 0,1495
                pop        ax        ;        pop ax
$DGL 0,1496
                MOVW        mk1,ax        ;        mk1=ax
$DGL 0,1497
                pop        ax        ;        pop ax
$DGL 0,1498
                MOVW        mk0,ax        ;        mk0=ax
$DGL 0,1499
                pop        psw        ;        pop psw
        
$DGL 0,1501
                pop        ax        ;        pop ax
$DGL 0,1502
                MOV        i,a        ;        i=a
$DGL 0,1503
                pop        hl        ;        pop hl
                INC        i
                BR        ?L117
$DGL 0,1504
?L118:                                ;     next
$DGL 0,1505
ret                                ;ret  
;妿蓵幆檸蠌帿廕婸擮block媍曽弾蹟帺墡綃幙姈墵婁宒殠貚J峇block恡庘愴
;晭諛g嫀覌P擮block恡庘彉槑螇幙姖,攷箥駢幟拵趶槝幬槑矓闀麖庅媍崫妅
$DGL 0,1508
selfprogrampro2:                ;selfprogrampro2:  
$DGL 0,1509
                MOV        WDTE,#0ACH        ;        WDTE=#0ACH
$DGL 0,1510
                push        psw        ;        push psw
$DGL 0,1511
                di                ;        di
$DGL 0,1512
                MOVW        ax,mk0        ;        ax=mk0
$DGL 0,1513
                push        ax        ;        push ax
$DGL 0,1514
                MOVW        mk0,#0ffffh        ;        mk0=#0ffffh
$DGL 0,1515
                MOVW        ax,mk1        ;        ax=mk1
$DGL 0,1516
                push        ax        ;        push ax
$DGL 0,1517
                MOVW        mk1,#0ffffh        ;        mk1=#0ffffh
$DGL 0,1518
                MOV        ADPC,#04h        ;        ADPC=#04h
$DGL 0,1519
                clr1        pm2.1        ;        clr1 pm2.1
$DGL 0,1520
                set1        p2.1        ;        set1 p2.1
     
$DGL 0,1522
                call        !_FlashStart        ;        call !_FlashStart
$DGL 0,1523
                MOVW        ax,#b100EntryRAM        ;        ax=#b100EntryRAM
$DGL 0,1524
                call        !_FlashEnv        ;        call !_FlashEnv
$DGL 0,1525
                call        !_CheckFLMD        ;        call !_CheckFLMD
$DGL 0,1526
                MOV        status,a        ;        status=a
$DGL 0,1527
                CMP        a,#0        ;        if(a!=#0)
                BZ        $?L122
$DGL 0,1528
                call        !selfprogerrmsg        ;           call !selfprogerrmsg
$DGL 0,1529
?L122:                                ;        endif
     
$DGL 0,1531
                MOV        i,#0        ;     for(i=#0;i<#3;i++)  
?L123:
                CMP        i,#3
                BNC        $?L124
$DGL 0,1532
                MOVW        ax,tEEPROM_BLOCK        ;        ax=tEEPROM_BLOCK
$DGL 0,1533
                MOVW        hl,ax        ;        hl=ax
$DGL 0,1534
                MOV        a,[hl]        ;        a=[hl]
$DGL 0,1535
                MOV        b,a        ;        b=a                             ;婸擮block崕?
$DGL 0,1536
                MOV        a,#0        ;        a=#0                            ;婸擮bank崕?
$DGL 0,1537
                call        !_FlashBlockBlankCheck        ;        call !_FlashBlockBlankCheck
$DGL 0,1538
                MOV        status,a        ;        status=a
$DGL 0,1539
                CMP        a,#27        ;        if(a!=#27)
                BZ        $?L125
$DGL 0,1540
                BR        ?L124        ;           break
$DGL 0,1541
?L125:                                ;        endif
$DGL 0,1542
                CMP        a,#27        ;        if(a==#27)
                BNZ        $?L126
$DGL 0,1543
                MOVW        ax,tEEPROM_BLOCK        ;           ax=tEEPROM_BLOCK
$DGL 0,1544
                MOVW        hl,ax        ;           hl=ax
$DGL 0,1545
                MOV        a,[hl]        ;           a=[hl]                       ;婸擮block崕?
$DGL 0,1546
                MOV        b,a        ;           b=a                          ;婸擮block崕?
$DGL 0,1547
                MOV        a,#0        ;           a=#0
$DGL 0,1548
                call        !_FlashBlockErase        ;           call !_FlashBlockErase
$DGL 0,1549
                MOV        status,a        ;           status=a
$DGL 0,1550
                CMP        a,#26        ;           if(a!=#26)
                BZ        $?L127
$DGL 0,1551
                BR        ?L124        ;              break
$DGL 0,1552
?L127:                                ;           endif
$DGL 0,1553
?L126:                                ;        endif
$DGL 0,1554
                CMP        status,#0        ;        if(status!=#0)
                BZ        $?L128
$DGL 0,1555
                BR        ?L124        ;          break
$DGL 0,1556
?L128:                                ;        endif
                INC        i
                BR        ?L123
$DGL 0,1557
?L124:                                ;     next
$DGL 0,1558
                CMP        status,#0        ;     if(status!=#0)
                BZ        $?L129
$DGL 0,1559
                call        !selfprogerrmsg        ;        call !selfprogerrmsg
$DGL 0,1560
?L129:                                ;     endif                             ;墡繆潒P擮block,檸覊儛I晭簭槝幬槑矓闀麖庅媍崫妅
$DGL 0,1561
                MOVW        ax,tempaddress        ;        ax=tempaddress
$DGL 0,1562
                MOVW        bc,ax        ;        bc=ax
$DGL 0,1563
                MOVW        ax,tEEPROM_BLOCK        ;        ax=tEEPROM_BLOCK
$DGL 0,1564
                MOVW        hl,ax        ;        hl=ax
$DGL 0,1565
                MOV        a,[hl]        ;        a=[hl]
$DGL 0,1566
                call        !BlockToAddress        ;        call !BlockToAddress
$DGL 0,1567
                call        !twobytes_add        ;        call !twobytes_add
$DGL 0,1568
                MOVW        writeaddress,ax        ;        writeaddress=ax
$DGL 0,1569
                MOV        writebank,#0        ;        writebank=#0
$DGL 0,1570
                MOV        a,conslength        ;        a=conslength
$DGL 0,1571
                MOV        writeflashlength,a        ;        writeflashlength=a                       ;廕婸擮曽弾蹣幉旈欵婸婁宒媍棊箾幜泿?
$DGL 0,1572
                MOVW        ax,tEEPROM_BLOCK        ;        ax=tEEPROM_BLOCK
$DGL 0,1573
                MOVW        hl,ax        ;        hl=ax
$DGL 0,1574
                MOV        a,[hl]        ;        a=[hl]
$DGL 0,1575
                MOV        temp,a        ;        temp=a
$DGL 0,1576
                MOVW        hl,#DataBuffer        ;        hl=#DataBuffer
$DGL 0,1577
                call        !flashwrite_sub1        ;        call !flashwrite_sub1
$DGL 0,1578
                call        !_FlashEnd        ;        call !_FlashEnd
$DGL 0,1579
                clr1        p2.1        ;        clr1 p2.1
$DGL 0,1580
                pop        ax        ;        pop ax
$DGL 0,1581
                MOVW        mk1,ax        ;        mk1=ax
$DGL 0,1582
                pop        ax        ;        pop ax
$DGL 0,1583
                MOVW        mk0,ax        ;        mk0=ax
$DGL 0,1584
                pop        psw        ;        pop psw
$DGL 0,1585
ret                                ;ret        

$DGL 0,1587
selfprogrampro3:                ;selfprogrampro3:
$DGL 0,1588
                MOVW        ax,#3800h        ;   ax=#3800h
$DGL 0,1589
                MOVW        hl,ax        ;   hl=ax
$DGL 0,1590
                MOV        i,#0        ;   FOR(i=#0;i<#10;i++)
?L130:
                CMP        i,#10
                BC        $?L131
                BR        ?L132
?L131:
$DGL 0,1591
                MOV        WDTE,#0ACH        ;        WDTE=#0ACH
$DGL 0,1592
                MOVW        de,#EEPROMBuf        ;        de=#EEPROMBuf
$DGL 0,1593
                MOV        a,[hl]        ;        if([hl]==#0FFH)(a)
                CMP        a,#0FFH
                BNZ        $?L133
$DGL 0,1594
                br        !continuepro1        ;              br !continuepro1
$DGL 0,1595
?L133:                                ;        endif
$DGL 0,1596
                MOV        j,#0        ;        for(j=#0;j<#100;j++)
?L134:
                CMP        j,#100
                BNC        $?L135
$DGL 0,1597
                MOV        a,[hl]        ;           a=[hl]
$DGL 0,1598
                MOV        [de],a        ;           [de]=a
$DGL 0,1599
                INCW        hl        ;           hl++
$DGL 0,1600
                INCW        de        ;           de++
                INC        j
                BR        ?L134
$DGL 0,1601
?L135:                                ;        next
$DGL 0,1602
                MOV        a,keynumber        ;        a=keynumber
$DGL 0,1603
                DEC        a        ;        a--
$DGL 0,1604
                cmp        a,i        ;        cmp a,i
$DGL 0,1605
                bz        $cycleend        ;        bz  $cycleend                  ;斿崨殩媆婸擮曽弾蹕c棊箾幜,欚棊〝O拞檸蠌帿槑矓?棊軜鏆幾槑矓?泜櫃弾藭幊榰慾曽弾蹕c栦嶼
        
$DGL 0,1607
                push        hl        ;        push hl
$DGL 0,1608
                MOV        a,i        ;        a=i
$DGL 0,1609
                push        ax        ;        push ax
$DGL 0,1610
                MOVW        ax,tEEPROM_BLOCK        ;        ax=tEEPROM_BLOCK
$DGL 0,1611
                MOVW        hl,ax        ;        hl=ax
$DGL 0,1612
                MOV        a,[hl]        ;        a=[hl]
$DGL 0,1613
                MOV        temp,a        ;        temp=a
$DGL 0,1614
                call        !selfprogramsub1        ;        call !selfprogramsub1
$DGL 0,1615
                MOV        WDTE,#0ACH        ;        WDTE=#0ACH
$DGL 0,1616
                push        psw        ;        push psw
$DGL 0,1617
                di                ;        di
$DGL 0,1618
                MOVW        ax,mk0        ;        ax=mk0
$DGL 0,1619
                push        ax        ;        push ax
$DGL 0,1620
                MOVW        mk0,#0ffffh        ;        mk0=#0ffffh
$DGL 0,1621
                MOVW        ax,mk1        ;        ax=mk1
$DGL 0,1622
                push        ax        ;        push ax
$DGL 0,1623
                MOVW        mk1,#0ffffh        ;        mk1=#0ffffh
$DGL 0,1624
                MOV        ADPC,#04h        ;        ADPC=#04h
$DGL 0,1625
                clr1        pm2.1        ;        clr1 pm2.1
$DGL 0,1626
                set1        p2.1        ;        set1 p2.1
        
$DGL 0,1628
                call        !_FlashStart        ;        call !_FlashStart
$DGL 0,1629
                MOVW        ax,#b100EntryRAM        ;        ax=#b100EntryRAM
$DGL 0,1630
                call        !_FlashEnv        ;        call !_FlashEnv
$DGL 0,1631
                call        !_CheckFLMD        ;        call !_CheckFLMD
$DGL 0,1632
                MOV        status,a        ;        status=a
$DGL 0,1633
                CMP        a,#0        ;        if(a!=#0)
                BZ        $?L136
$DGL 0,1634
                call        !selfprogerrmsg        ;           call !selfprogerrmsg
$DGL 0,1635
?L136:                                ;        endif                        ;廕hl,i曽泿硥B嶤擃悗矙幰墐檸覎駮幏歜                    
        
$DGL 0,1637
                MOVW        hl,#EEPROMBuf        ;        hl=#EEPROMBuf  
$DGL 0,1638
                call        !flashwrite_sub1        ;        call !flashwrite_sub1        
$DGL 0,1639
                call        !_FlashEnd        ;        call !_FlashEnd
$DGL 0,1640
                clr1        p2.1        ;        clr1 p2.1
$DGL 0,1641
                pop        ax        ;        pop ax
$DGL 0,1642
                MOVW        mk1,ax        ;        mk1=ax
$DGL 0,1643
                pop        ax        ;        pop ax
$DGL 0,1644
                MOVW        mk0,ax        ;        mk0=ax
$DGL 0,1645
                pop        psw        ;        pop psw

$DGL 0,1647
                pop        ax        ;        pop ax
$DGL 0,1648
                MOV        i,a        ;        i=a
$DGL 0,1649
                pop        hl        ;        pop hl
$DGL 0,1650
                br        !cycleend        ;        br !cycleend
$DGL 0,1651
continuepro1:                        ;continuepro1:
$DGL 0,1652
                MOV        a,l        ;        l+=#100,cy(a)
                ADDC        a,#100
                MOV        l,a
$DGL 0,1653
                MOV        a,h        ;        h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,1654
cycleend:                        ;cycleend:
                INC        i
                BR        ?L130
$DGL 0,1655
?L132:                                ;   NEXT
$DGL 0,1656
                ei                ;        ei
$DGL 0,1657
ret                                ;ret
$DGL 0,1658
selfprogramsub1:                ;selfprogramsub1:
$DGL 0,1659
                MOV        a,i        ;        a=i
$DGL 0,1660
                MOV        x,#100        ;        x=#100
$DGL 0,1661
                mulu        x        ;        mulu x
$DGL 0,1662
                MOVW        bc,ax        ;        bc=ax
$DGL 0,1663
                MOVW        ax,tEEPROM_BLOCK        ;        ax=tEEPROM_BLOCK
$DGL 0,1664
                MOVW        hl,ax        ;        hl=ax
$DGL 0,1665
                MOV        a,[hl]        ;        a=[hl]
$DGL 0,1666
                call        !BlockToAddress        ;        call !BlockToAddress
$DGL 0,1667
                call        !twobytes_add        ;        call !twobytes_add
$DGL 0,1668
                MOVW        writeaddress,ax        ;        writeaddress=ax
$DGL 0,1669
                MOV        writebank,#0        ;        writebank=#0
$DGL 0,1670
                MOV        writeflashlength,#25        ;        writeflashlength=#25
$DGL 0,1671
ret                                ;ret
      
$DGL 0,1673
twobytes_add:                        ;twobytes_add:
$DGL 0,1674
                push        bc        ;   push bc
$DGL 0,1675
                push        de        ;   push de
$DGL 0,1676
                MOVW        de,ax        ;   de=ax
$DGL 0,1677
                MOV        a,x        ;   a=x
$DGL 0,1678
                clr1        cy        ;   clr1 cy
$DGL 0,1679
                addc        a,c        ;   addc a,c
$DGL 0,1680
                MOV        x,a        ;   x=a
$DGL 0,1681
                MOV        a,d        ;   a=d
$DGL 0,1682
                addc        a,b        ;   addc a,b
$DGL 0,1683
                pop        de        ;   pop de
$DGL 0,1684
                pop        bc        ;   pop bc
$DGL 0,1685
ret                                ;ret

$DGL 0,1687
flashwrite_sub:                        ;flashwrite_sub:
$DGL 0,1688
                MOV        a,#0        ;for(i=#0;i<writeflashlength;i++)(a)
                MOV        i,a
?L137:
                MOV        a,i
                CMP        a,writeflashlength
                BNC        $?L138
$DGL 0,1689
                MOV        wdte,#0ach        ;     wdte=#0ach
$DGL 0,1690
                MOVW        ax,#writeaddress        ;     ax=#writeaddress
$DGL 0,1691
                MOV        b,#1        ;     b=#1
$DGL 0,1692
                MOV        j,#0        ;     for(j=#0;j<#3;j++)
?L139:
                CMP        j,#3
                BNC        $?L140
$DGL 0,1693
                call        !_FlashWordWrite        ;       call !_FlashWordWrite
$DGL 0,1694
                MOV        status,a        ;       status=a
$DGL 0,1695
                CMP        a,#28        ;       if(a==#28)
                BNZ        $?L141
$DGL 0,1696
                BR        ?L139        ;          continue
$DGL 0,1697
?L141:                                ;       endif
$DGL 0,1698
                CMP        a,#0        ;       if(a!=#0)
                BZ        $?L142
$DGL 0,1699
                BR        ?L140        ;         break
$DGL 0,1700
?L142:                                ;       endif
$DGL 0,1701
                MOV        a,#0        ;       a=#0
$DGL 0,1702
                MOV        b,#0EH        ;       b=#0EH
$DGL 0,1703
                call        !_FlashBlockVerify        ;       call !_FlashBlockVerify
$DGL 0,1704
                MOV        status,a        ;       status=a
$DGL 0,1705
                CMP        a,#27        ;       if(a!=#27)
                BZ        $?L143
$DGL 0,1706
                BR        ?L140        ;         break
$DGL 0,1707
?L143:                                ;       endif
                INC        j
                BR        ?L139
$DGL 0,1708
?L140:                                ;     next
$DGL 0,1709
                MOVW        ax,!writeaddress        ;     !writeaddress+=#4(ax)
                ADDW        ax,#4
                MOVW        !writeaddress,ax
$DGL 0,1710
                INCW        hl        ;     hl++
$DGL 0,1711
                INCW        hl        ;     hl++
$DGL 0,1712
                INCW        hl        ;     hl++
$DGL 0,1713
                INCW        hl        ;     hl++
$DGL 0,1714
                CMP        status,#0        ;     if(status!=#0)
                BZ        $?L144
$DGL 0,1715
                BR        ?L138        ;        break
$DGL 0,1716
?L144:                                ;     endif
                MOV        a,i
                INC        a
                MOV        i,a
                BR        ?L137
$DGL 0,1717
?L138:                                ;   next
$DGL 0,1718
                CMP        status,#0        ;   if(status!=#0)
                BZ        $?L145
$DGL 0,1719
                call        !selfprogerrmsg        ;        call !selfprogerrmsg
$DGL 0,1720
?L145:                                ;   endif
$DGL 0,1721
ret                                ;ret

$DGL 0,1723
flashwrite_sub1:                ;flashwrite_sub1:
$DGL 0,1724
                MOV        a,#0        ;for(i=#0;i<writeflashlength;i++)(a)
                MOV        i,a
?L146:
                MOV        a,i
                CMP        a,writeflashlength
                BNC        $?L147
$DGL 0,1725
                MOV        WDTE,#0ACH        ;     WDTE=#0ACH
$DGL 0,1726
                MOVW        ax,#writeaddress        ;     ax=#writeaddress
$DGL 0,1727
                MOV        b,#1        ;     b=#1
$DGL 0,1728
                MOV        j,#0        ;     for(j=#0;j<#3;j++)
?L148:
                CMP        j,#3
                BNC        $?L149
$DGL 0,1729
                call        !_FlashWordWrite        ;       call !_FlashWordWrite
$DGL 0,1730
                MOV        status,a        ;       status=a
$DGL 0,1731
                CMP        a,#28        ;       if(a==#28)
                BNZ        $?L150
$DGL 0,1732
                BR        ?L148        ;          continue
$DGL 0,1733
?L150:                                ;       endif
$DGL 0,1734
                CMP        a,#0        ;       if(a!=#0)
                BZ        $?L151
$DGL 0,1735
                BR        ?L149        ;         break
$DGL 0,1736
?L151:                                ;       endif
      
$DGL 0,1738
                MOV        a,temp        ;       a=temp
$DGL 0,1739
                MOV        b,a        ;       b=a
$DGL 0,1740
                MOV        a,#0        ;       a=#0
$DGL 0,1741
                call        !_FlashBlockVerify        ;       call !_FlashBlockVerify
$DGL 0,1742
                MOV        status,a        ;       status=a
$DGL 0,1743
                CMP        a,#27        ;       if(a!=#27)
                BZ        $?L152
$DGL 0,1744
                BR        ?L149        ;         break
$DGL 0,1745
?L152:                                ;       endif
                INC        j
                BR        ?L148
$DGL 0,1746
?L149:                                ;     next
$DGL 0,1747
                MOVW        ax,!writeaddress        ;     !writeaddress+=#4(ax)
                ADDW        ax,#4
                MOVW        !writeaddress,ax
$DGL 0,1748
                INCW        hl        ;     hl++
$DGL 0,1749
                INCW        hl        ;     hl++
$DGL 0,1750
                INCW        hl        ;     hl++
$DGL 0,1751
                INCW        hl        ;     hl++
$DGL 0,1752
                CMP        status,#0        ;     if(status!=#0)
                BZ        $?L153
$DGL 0,1753
                BR        ?L147        ;        break
$DGL 0,1754
?L153:                                ;     endif
                MOV        a,i
                INC        a
                MOV        i,a
                BR        ?L146
$DGL 0,1755
?L147:                                ;   next
$DGL 0,1756
                CMP        status,#0        ;   if(status!=#0)
                BZ        $?L154
$DGL 0,1757
                call        !selfprogerrmsg        ;        call !selfprogerrmsg
$DGL 0,1758
?L154:                                ;   endif
$DGL 0,1759
ret                                ;ret

$DGL 0,1761
erase_common:                        ;erase_common:
$DGL 0,1762
                MOV        i,#0        ;     for(i=#0;i<#3;i++)  
?L155:
                CMP        i,#3
                BNC        $?L156
$DGL 0,1763
                MOV        a,#0        ;        a=#0
$DGL 0,1764
                MOV        b,#0EH        ;        b=#0EH
$DGL 0,1765
                call        !_FlashBlockBlankCheck        ;        call !_FlashBlockBlankCheck
$DGL 0,1766
                MOV        status,a        ;        status=a
$DGL 0,1767
                CMP        a,#27        ;        if(a!=#27)
                BZ        $?L157
$DGL 0,1768
                BR        ?L156        ;           break
$DGL 0,1769
?L157:                                ;        endif
$DGL 0,1770
                CMP        a,#27        ;        if(a==#27)
                BNZ        $?L158
$DGL 0,1771
                MOV        a,#0        ;           a=#0
$DGL 0,1772
                MOV        b,#0EH        ;           b=#0EH
$DGL 0,1773
                call        !_FlashBlockErase        ;           call !_FlashBlockErase
$DGL 0,1774
                MOV        status,a        ;           status=a
$DGL 0,1775
                CMP        a,#26        ;           if(a!=#26)
                BZ        $?L159
$DGL 0,1776
                BR        ?L156        ;              break
$DGL 0,1777
?L159:                                ;           endif
$DGL 0,1778
?L158:                                ;        endif
$DGL 0,1779
                CMP        status,#0        ;        if(status!=#0)
                BZ        $?L160
$DGL 0,1780
                BR        ?L156        ;          break
$DGL 0,1781
?L160:                                ;        endif
                INC        i
                BR        ?L155
$DGL 0,1782
?L156:                                ;     next
$DGL 0,1783
                CMP        status,#0        ;     if(status!=#0)
                BZ        $?L161
$DGL 0,1784
                call        !selfprogerrmsg        ;        call !selfprogerrmsg
$DGL 0,1785
?L161:                                ;     endif
$DGL 0,1786
ret                                ;ret
$DGL 0,1787
selfprogerrmsg:                        ;selfprogerrmsg:
$DGL 0,1788
                                ;     switch(status)
$DGL 0,1789
                CMP        status,#0        ;        case 0:
                BNZ        $?L162
$DGL 0,1790
                MOV        status,#0        ;           status=#0
$DGL 0,1791
                BR        ?L163        ;        break
$DGL 0,1792
?L162:                                ;        case 1:
                CMP        status,#1
                BNZ        $?L164
$DGL 0,1793
                MOV        status,#1        ;           status=#1   
$DGL 0,1794
                BR        ?L163        ;        break
$DGL 0,1795
?L164:                                ;        case 5:
                CMP        status,#5
                BNZ        $?L165
$DGL 0,1796
                MOV        status,#2        ;           status=#2
$DGL 0,1797
                BR        ?L163        ;        break
$DGL 0,1798
?L165:                                ;        case 16:
                CMP        status,#16
                BNZ        $?L166
$DGL 0,1799
                MOV        status,#3        ;           status=#3
$DGL 0,1800
                BR        ?L163        ;        break
$DGL 0,1801
?L166:                                ;        case 26:
                CMP        status,#26
                BNZ        $?L167
$DGL 0,1802
                MOV        status,#4        ;           status=#4
$DGL 0,1803
                BR        ?L163        ;        break
$DGL 0,1804
?L167:                                ;        case 27:
                CMP        status,#27
                BNZ        $?L168
$DGL 0,1805
                MOV        status,#5        ;           status=#5
$DGL 0,1806
                BR        ?L163        ;        break
$DGL 0,1807
?L168:                                ;        case 28:
                CMP        status,#28
                BNZ        $?L169
$DGL 0,1808
                MOV        status,#7        ;           status=#7
$DGL 0,1809
                BR        ?L163        ;        break
$DGL 0,1810
?L169:                                ;        case 29:
                CMP        status,#29
                BNZ        $?L170
$DGL 0,1811
                MOV        status,#8        ;           status=#8
$DGL 0,1812
                BR        ?L163        ;        break
$DGL 0,1813
?L170:                                ;        case 31:
                CMP        status,#31
                BNZ        $?L171
$DGL 0,1814
                MOV        status,#9        ;           status=#9
$DGL 0,1815
                BR        ?L163        ;        break
$DGL 0,1816
?L171:                                ;        case 32:
                CMP        status,#32
                BNZ        $?L172
$DGL 0,1817
                MOV        status,#10        ;           status=#10
$DGL 0,1818
                BR        ?L163        ;        break
$DGL 0,1819
?L172:                                ;        default:
$DGL 0,1820
                MOV        status,#15        ;           status=#15
$DGL 0,1821
?L163:                                ;     ends
$DGL 0,1822
ret                                ;ret
$DGL 0,1823
writelength_conv:                ;writelength_conv:
$DGL 0,1824
                push        ax        ;   push ax
$DGL 0,1825
                push        bc        ;   push bc
$DGL 0,1826
                push        de        ;   push de
$DGL 0,1827
                push        hl        ;   push hl
$DGL 0,1828
                MOV        a,datalength        ;   a=datalength
$DGL 0,1829
                clr1        cy        ;   clr1 cy
$DGL 0,1830
                ror        a,1        ;   ror a,1
$DGL 0,1831
                and        a,#01111111b        ;   and a,#01111111b
$DGL 0,1832
                clr1        cy        ;   clr1 cy
$DGL 0,1833
                ror        a,1        ;   ror a,1
$DGL 0,1834
                and        a,#00111111b        ;   and a,#00111111b
$DGL 0,1835
                MOV        temp,a        ;   temp=a
$DGL 0,1836
                clr1        cy        ;   clr1 cy
$DGL 0,1837
                rol        a,1        ;   rol a,1
$DGL 0,1838
                and        a,#11111110b        ;   and a,#11111110b
$DGL 0,1839
                clr1        cy        ;   clr1 cy
$DGL 0,1840
                rol        a,1        ;   rol a,1
$DGL 0,1841
                and        a,#11111100b        ;   and a,#11111100b
$DGL 0,1842
                MOV        x,a        ;   x=a
$DGL 0,1843
                MOV        a,datalength        ;   a=datalength
$DGL 0,1844
                clr1        cy        ;   clr1 cy
$DGL 0,1845
                subc        a,x        ;   subc a,x
$DGL 0,1846
                CMP        a,#0        ;   if(a!=#0)
                BZ        $?L173
$DGL 0,1847
                MOV        a,temp        ;     a=temp
$DGL 0,1848
                INC        a        ;     a++
$DGL 0,1849
                MOV        temp,a        ;     temp=a
$DGL 0,1850
?L173:                                ;   endif
$DGL 0,1851
                MOV        a,temp        ;   a=temp
$DGL 0,1852
                INC        a        ;   a++
$DGL 0,1853
                INC        a        ;   a++
$DGL 0,1854
                MOV        conslength,a        ;   conslength=a
$DGL 0,1855
                pop        hl        ;   pop hl
$DGL 0,1856
                pop        de        ;   pop de
$DGL 0,1857
                pop        bc        ;   pop bc
$DGL 0,1858
                pop        ax        ;   pop ax
$DGL 0,1859
ret                                ;ret

$DGL 0,1861
decompressdata:                        ;decompressdata:                       
$DGL 0,1862
                MOVW        hl,#EEPROMBuf        ;   hl=#EEPROMBuf
$DGL 0,1863
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,1864
                MOV        datalength,a        ;   datalength=a
$DGL 0,1865
                DEC        a        ;   a--
$DGL 0,1866
                DEC        a        ;   a--
$DGL 0,1867
                DEC        a        ;   a--
$DGL 0,1868
                DEC        a        ;   a--
$DGL 0,1869
                DEC        a        ;   a--
$DGL 0,1870
                DEC        a        ;   a--
$DGL 0,1871
                MOV        lengthcounter,a        ;   lengthcounter=a
$DGL 0,1872
                INCW        hl        ;   hl++
$DGL 0,1873
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,1874
                MOV        codelength,a        ;   codelength=a
$DGL 0,1875
                INCW        hl        ;   hl++
$DGL 0,1876
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,1877
                MOV        codetypenumber,a        ;   codetypenumber=a
$DGL 0,1878
                INC        a        ;   a++
$DGL 0,1879
                clr1        cy        ;   clr1 cy
$DGL 0,1880
                rol        a,1        ;   rol a,1
$DGL 0,1881
                and        a,#11111110b        ;   and a,#11111110b
$DGL 0,1882
                clr1        cy        ;   clr1 cy
$DGL 0,1883
                rol        a,1        ;   rol a,1
$DGL 0,1884
                and        a,#11111100b        ;   and a,#11111100b
$DGL 0,1885
                MOV        x,a        ;   x=a
$DGL 0,1886
                MOV        a,lengthcounter        ;   a=lengthcounter
$DGL 0,1887
                clr1        cy        ;   clr1 cy
$DGL 0,1888
                subc        a,x        ;   subc a,x
$DGL 0,1889
                MOV        lengthcounter,a        ;   lengthcounter=a
   
$DGL 0,1891
                MOV        flowbitnumber,#1        ;    flowbitnumber=#1
$DGL 0,1892
                MOV        tempcounter,#2        ;    tempcounter=#2
$DGL 0,1893
                CMP        codetypenumber,#2        ;    if(codetypenumber>=#2)
                BC        $?L174
$DGL 0,1894
decompress_pro:                        ;decompress_pro:
$DGL 0,1895
                MOV        a,tempcounter        ;       a=tempcounter
$DGL 0,1896
                clr1        cy        ;       clr1 cy
$DGL 0,1897
                rol        a,1        ;       rol a,1
$DGL 0,1898
                and        a,#11111110b        ;       and a,#11111110b
$DGL 0,1899
                MOV        tempcounter,a        ;       tempcounter=a
$DGL 0,1900
                DEC        a        ;       a--
$DGL 0,1901
                MOV        temp,a        ;       temp=a
$DGL 0,1902
                MOV        a,flowbitnumber        ;       a=flowbitnumber
$DGL 0,1903
                INC        a        ;       a++
$DGL 0,1904
                MOV        flowbitnumber,a        ;       flowbitnumber=a
$DGL 0,1905
                MOV        a,temp        ;       a=temp      
$DGL 0,1906
                cmp        a,codetypenumber        ;       cmp a,codetypenumber
$DGL 0,1907
                bc        $decompress_pro        ;       bc $decompress_pro
$DGL 0,1908
?L174:                                ;    endif
   
$DGL 0,1910
                MOVW        hl,#EEPROMBuf        ;    hl=#EEPROMBuf
$DGL 0,1911
                INCW        hl        ;    hl++
$DGL 0,1912
                INCW        hl        ;    hl++
$DGL 0,1913
                MOVW        de,#codetypedata        ;    de=#codetypedata
$DGL 0,1914
                MOV        i,#0        ;    i=#0
$DGL 0,1915
transfer3:                        ;transfer3:
$DGL 0,1916
                INCW        hl        ;    hl++

$DGL 0,1918
                MOV        a,[hl]        ;    a=[hl]
$DGL 0,1919
                MOV        [de],a        ;    [de]=a
$DGL 0,1920
                INCW        hl        ;    hl++
$DGL 0,1921
                INCW        de        ;    de++
$DGL 0,1922
                MOV        a,[hl]        ;    a=[hl]
$DGL 0,1923
                MOV        [de],a        ;    [de]=a
$DGL 0,1924
                INCW        hl        ;    hl++
$DGL 0,1925
                INCW        de        ;    de++
$DGL 0,1926
                MOV        a,[hl]        ;    a=[hl]
$DGL 0,1927
                MOV        [de],a        ;    [de]=a
$DGL 0,1928
                INCW        hl        ;    hl++
$DGL 0,1929
                INCW        de        ;    de++
$DGL 0,1930
                MOV        a,[hl]        ;    a=[hl]
$DGL 0,1931
                MOV        [de],a        ;    [de]=a
$DGL 0,1932
                INCW        de        ;    de++
$DGL 0,1933
                INC        i        ;    i++
$DGL 0,1934
                MOV        a,i        ;    a=i
$DGL 0,1935
                DEC        a        ;    a--
$DGL 0,1936
                cmp        a,codetypenumber        ;    cmp a,codetypenumber
$DGL 0,1937
                bnz        $transfer3        ;    bnz $transfer3
$DGL 0,1938
                INCW        hl        ;    hl++                  ;庘岒檸箤魷u弝
   
$DGL 0,1940
                CMP        flowbitnumber,#1        ;    if(flowbitnumber==#1)
                BNZ        $?L175
$DGL 0,1941
                MOV        flowbitnumber,#2        ;      flowbitnumber=#2
$DGL 0,1942
?L175:                                ;    endif
   
$DGL 0,1944
                CMP        flowbitnumber,#2        ;    IF(flowbitnumber==#2)    ;攐帋艎幧妿ccodetypenumber姇晭簳麤幊晥泿翖帹0
                BZ        $?L176
                BR        ?L177
?L176:
$DGL 0,1945
                MOV        a,codelength        ;       a=codelength
$DGL 0,1946
                BF        a.0,$?L178        ;       if_bit(a.0)
$DGL 0,1947
                set1        subflag        ;         set1 subflag
$DGL 0,1948
                DEC        lengthcounter        ;         lengthcounter--
                BR        ?L179
$DGL 0,1949
?L178:                                ;       else
$DGL 0,1950
                BF        a.1,$?L180        ;         if_bit(a.1)
$DGL 0,1951
                set1        subflag        ;           set1 subflag
$DGL 0,1952
                DEC        lengthcounter        ;           lengthcounter--
$DGL 0,1953
?L180:                                ;         endif
$DGL 0,1954
?L179:                                ;       endif
$DGL 0,1955
                MOV        a,lengthcounter        ;       a=lengthcounter
$DGL 0,1956
                clr1        cy        ;       clr1 cy
$DGL 0,1957
                rol        a,1        ;       rol a,1
$DGL 0,1958
                and        a,#11111110b        ;       and a,#11111110b
$DGL 0,1959
                clr1        cy        ;       clr1 cy
$DGL 0,1960
                rol        a,1        ;       rol a,1
$DGL 0,1961
                and        a,#11111100b        ;       and a,#11111100b
$DGL 0,1962
                MOV        x,a        ;       x=a
$DGL 0,1963
                MOV        a,codelength        ;       a=codelength
$DGL 0,1964
                clr1        cy        ;       clr1 cy
$DGL 0,1965
                subc        a,x        ;       subc a,x
$DGL 0,1966
                MOV        temp,a        ;       temp=a
         
$DGL 0,1968
                INCW        hl        ;       hl++
$DGL 0,1969
                MOV        i,#0        ;       i=#0
$DGL 0,1970
                MOVW        de,#codeflowbyte        ;       de=#codeflowbyte
$DGL 0,1971
transfer4:                        ;transfer4:
$DGL 0,1972
                MOV        a,[hl]        ;       a=[hl]
      
$DGL 0,1974
                and        a,#00000011b        ;       and a,#00000011b
$DGL 0,1975
                MOV        [de],a        ;       [de]=a
      
$DGL 0,1977
                INCW        de        ;       de++
$DGL 0,1978
                MOV        a,[hl]        ;       a=[hl]
$DGL 0,1979
                and        a,#00001100b        ;       and a,#00001100b
$DGL 0,1980
                clr1        cy        ;       clr1 cy
$DGL 0,1981
                ror        a,1        ;       ror a,1
$DGL 0,1982
                and        a,#01111111b        ;       and a,#01111111b
$DGL 0,1983
                clr1        cy        ;       clr1 cy
$DGL 0,1984
                ror        a,1        ;       ror a,1
$DGL 0,1985
                and        a,#01111111b        ;       and a,#01111111b
$DGL 0,1986
                MOV        [de],a        ;       [de]=a
      
$DGL 0,1988
                INCW        de        ;       de++
$DGL 0,1989
                MOV        a,[hl]        ;       a=[hl]
$DGL 0,1990
                and        a,#00110000b        ;       and a,#00110000b
$DGL 0,1991
                ror        a,1        ;       ror a,1
$DGL 0,1992
                ror        a,1        ;       ror a,1
$DGL 0,1993
                ror        a,1        ;       ror a,1
$DGL 0,1994
                ror        a,1        ;       ror a,1
$DGL 0,1995
                MOV        [de],a        ;       [de]=a
      
$DGL 0,1997
                INCW        de        ;       de++
$DGL 0,1998
                MOV        a,[hl]        ;       a=[hl]
$DGL 0,1999
                and        a,#11000000b        ;       and a,#11000000b
$DGL 0,2000
                ror        a,1        ;       ror a,1
$DGL 0,2001
                ror        a,1        ;       ror a,1
$DGL 0,2002
                ror        a,1        ;       ror a,1
$DGL 0,2003
                ror        a,1        ;       ror a,1
$DGL 0,2004
                ror        a,1        ;       ror a,1
$DGL 0,2005
                ror        a,1        ;       ror a,1
$DGL 0,2006
                MOV        [de],a        ;       [de]=a
      
$DGL 0,2008
                INCW        hl        ;       hl++
$DGL 0,2009
                INCW        de        ;       de++
      
$DGL 0,2011
                INC        i        ;       i++
$DGL 0,2012
                MOV        a,lengthcounter        ;       a=lengthcounter     ;嫀襈EC媍孉戦岋晭粣幉朤,妿蓧剳^棊?
$DGL 0,2013
                cmp        a,i        ;       cmp a,i
$DGL 0,2014
                bnz        $transfer4        ;       bnz $transfer4
      
$DGL 0,2016
                BF        subflag,$?L181        ;       if_bit(subflag)
$DGL 0,2017
                clr1        subflag        ;         clr1 subflag
$DGL 0,2018
                MOV        i,#0        ;         i=#0
$DGL 0,2019
transfer5:                        ;transfer5:
$DGL 0,2020
                call        !transfer5sub        ;         call !transfer5sub
$DGL 0,2021
                INC        i        ;           i++
$DGL 0,2022
                MOV        a,i        ;         a=i
$DGL 0,2023
                cmp        a,temp        ;         cmp a,temp
$DGL 0,2024
                bnz        $transfer5        ;         bnz $transfer5
$DGL 0,2025
                INCW        hl        ;         hl++
$DGL 0,2026
?L181:                                ;       endif
      
$DGL 0,2028
                MOV        a,[hl]        ;       endcode=[hl](a)
                MOV        endcode,a
$DGL 0,2029
                INCW        hl        ;       hl++
$DGL 0,2030
                MOV        a,[hl]        ;       endcode+1=[hl](a)
                MOV        endcode+1,a
$DGL 0,2031
                INCW        hl        ;       hl++
$DGL 0,2032
                INCW        hl        ;       hl++
$DGL 0,2033
                MOV        a,[hl]        ;       intervaloverflow1=[hl](a)
                MOV        intervaloverflow1,a
$DGL 0,2034
                INCW        hl        ;       hl++
$DGL 0,2035
                MOV        a,[hl]        ;       conscounter1=[hl](a)
                MOV        conscounter1,a
$DGL 0,2036
                INCW        hl        ;       hl++
$DGL 0,2037
                MOV        a,[hl]        ;       intervaloverflow2=[hl](a)
                MOV        intervaloverflow2,a
$DGL 0,2038
                INCW        hl        ;       hl++
$DGL 0,2039
                MOV        a,[hl]        ;       conscounter2=[hl](a)
                MOV        conscounter2,a
$DGL 0,2040
                INCW        hl        ;       hl++
$DGL 0,2041
                MOV        a,[hl]        ;       intervaloverflow3=[hl](a)
                MOV        intervaloverflow3,a
$DGL 0,2042
                INCW        hl        ;       hl++
$DGL 0,2043
                MOV        a,[hl]        ;       conscounter3=[hl](a)
                MOV        conscounter3,a
$DGL 0,2044
?L177:                                ;    ENDIF
   
$DGL 0,2046
                MOV        a,flowbitnumber        ;    a=flowbitnumber
$DGL 0,2047
                CMP        a,#4        ;    if(a==#4)
                BNZ        $?L182
$DGL 0,2048
                MOV        flowbitnumber,#3        ;       flowbitnumber=#3
$DGL 0,2049
?L182:                                ;    endif
   
$DGL 0,2051
                MOV        a,flowbitnumber        ;    a=flowbitnumber
$DGL 0,2052
                CMP        flowbitnumber,#3        ;    IF(flowbitnumber==#3)
                BZ        $?L183
                BR        ?L184
?L183:
$DGL 0,2053
                MOV        a,codelength        ;       a=codelength
$DGL 0,2054
                BF        a.0,$?L185        ;       if_bit(a.0)
$DGL 0,2055
                set1        subflag        ;         set1 subflag
$DGL 0,2056
                DEC        lengthcounter        ;         lengthcounter--
$DGL 0,2057
?L185:                                ;       endif
      
$DGL 0,2059
                INCW        hl        ;     hl++
$DGL 0,2060
                MOV        i,#0        ;     i=#0
$DGL 0,2061
                MOVW        de,#codeflowbyte        ;     de=#codeflowbyte
$DGL 0,2062
transfer6:                        ;transfer6:
$DGL 0,2063
                MOV        a,[hl]        ;     a=[hl]
     
$DGL 0,2065
                and        a,#00001111b        ;     and a,#00001111b
$DGL 0,2066
                MOV        [de],a        ;     [de]=a
     
$DGL 0,2068
                INCW        de        ;     de++
$DGL 0,2069
                MOV        a,[hl]        ;     a=[hl]
$DGL 0,2070
                and        a,#11110000b        ;     and a,#11110000b
$DGL 0,2071
                ror        a,1        ;     ror a,1
$DGL 0,2072
                ror        a,1        ;     ror a,1
$DGL 0,2073
                ror        a,1        ;     ror a,1
$DGL 0,2074
                ror        a,1        ;     ror a,1
$DGL 0,2075
                MOV        [de],a        ;     [de]=a
$DGL 0,2076
                INCW        hl        ;     hl++
$DGL 0,2077
                INCW        de        ;     de++
$DGL 0,2078
                INC        i        ;     i++
$DGL 0,2079
                MOV        a,lengthcounter        ;     a=lengthcounter
$DGL 0,2080
                cmp        a,i        ;     cmp a,i
$DGL 0,2081
                bnz        $transfer6        ;     bnz $transfer6
     
$DGL 0,2083
                BF        subflag,$?L186        ;     if_bit(subflag)
$DGL 0,2084
                clr1        subflag        ;       clr1 subflag
$DGL 0,2085
                MOV        a,[hl]        ;       a=[hl]
$DGL 0,2086
                MOV        [de],a        ;       [de]=a
$DGL 0,2087
                INCW        hl        ;       hl++
$DGL 0,2088
                INCW        de        ;       de++
$DGL 0,2089
?L186:                                ;     endif
     
$DGL 0,2091
                MOV        a,[hl]        ;     endcode=[hl](a)
                MOV        endcode,a
$DGL 0,2092
                INCW        hl        ;     hl++
$DGL 0,2093
                MOV        a,[hl]        ;     endcode+1=[hl](a)
                MOV        endcode+1,a
     
$DGL 0,2095
                INCW        hl        ;     hl++
$DGL 0,2096
                INCW        hl        ;     hl++
$DGL 0,2097
                MOV        a,[hl]        ;     intervaloverflow1=[hl](a)
                MOV        intervaloverflow1,a
$DGL 0,2098
                INCW        hl        ;     hl++
$DGL 0,2099
                MOV        a,[hl]        ;     conscounter1=[hl](a)
                MOV        conscounter1,a
$DGL 0,2100
                INCW        hl        ;     hl++
$DGL 0,2101
                MOV        a,[hl]        ;     intervaloverflow2=[hl](a)
                MOV        intervaloverflow2,a
$DGL 0,2102
                INCW        hl        ;     hl++
$DGL 0,2103
                MOV        a,[hl]        ;     conscounter2=[hl](a)
                MOV        conscounter2,a
$DGL 0,2104
                INCW        hl        ;     hl++
$DGL 0,2105
                MOV        a,[hl]        ;     intervaloverflow3=[hl](a)
                MOV        intervaloverflow3,a
$DGL 0,2106
                INCW        hl        ;     hl++
$DGL 0,2107
                MOV        a,[hl]        ;     conscounter3=[hl](a)
                MOV        conscounter3,a
$DGL 0,2108
?L184:                                ;    ENDIF
$DGL 0,2109
ret                                ;ret
$DGL 0,2110
transfer5sub:                        ;transfer5sub:
$DGL 0,2111
                CMP        i,#0        ;         if(i==#0)
                BNZ        $?L187
$DGL 0,2112
                MOV        a,[hl]        ;           a=[hl]
$DGL 0,2113
                and        a,#00000011b        ;           and a,#00000011b
$DGL 0,2114
                MOV        [de],a        ;           [de]=a
$DGL 0,2115
                INCW        de        ;           de++
                BR        ?L188
$DGL 0,2116
?L187:                                ;         else
$DGL 0,2117
                CMP        i,#1        ;           if(i==#1)
                BNZ        $?L189
$DGL 0,2118
                MOV        a,[hl]        ;              a=[hl]
$DGL 0,2119
                and        a,#00001100b        ;              and a,#00001100b
$DGL 0,2120
                ror        a,1        ;              ror a,1
$DGL 0,2121
                ror        a,1        ;              ror a,1
$DGL 0,2122
                MOV        [de],a        ;              [de]=a
$DGL 0,2123
                INCW        de        ;              de++
                BR        ?L190
$DGL 0,2124
?L189:                                ;           else
$DGL 0,2125
                CMP        i,#2        ;              if(i==#2)
                BNZ        $?L191
$DGL 0,2126
                MOV        a,[hl]        ;                a=[hl]
$DGL 0,2127
                and        a,#00110000b        ;                and a,#00110000b
$DGL 0,2128
                ror        a,1        ;                ror a,1
$DGL 0,2129
                ror        a,1        ;                ror a,1
$DGL 0,2130
                ror        a,1        ;                ror a,1
$DGL 0,2131
                ror        a,1        ;                ror a,1
$DGL 0,2132
                MOV        [de],a        ;                [de]=a
$DGL 0,2133
                INCW        de        ;                de++
$DGL 0,2134
?L191:                                ;              endif
$DGL 0,2135
?L190:                                ;           endif
$DGL 0,2136
?L188:                                ;         endif
$DGL 0,2137
ret                                ;ret
$DGL 0,2138
interval:                        ;interval:                   ;15.616ms
$DGL 0,2139
                set1        timerflag        ;  set1 timerflag
$DGL 0,2140
reti                                ;reti
$DGL 0,2141
keyscansub1:                        ;keyscansub1:
$DGL 0,2142
                call        !keyscansub        ;  call !keyscansub
$DGL 0,2143
                CMP        keypressedcounter,#1        ;  IF(keypressedcounter==#1)
                BZ        $?L192
                BR        ?L193
?L192:
$DGL 0,2144
                MOV        a,currentkeyid        ;            IF(currentkeyid==currentkeyidbak)(a)       
                CMP        a,currentkeyidbak
                BZ        $?L194
                BR        ?L195
?L194:
$DGL 0,2145
                INC        keyscantime        ;              keyscantime++
$DGL 0,2146
                CMP        keyscantime,#4        ;              IF(keyscantime==#4)                   
                BZ        $?L196
                BR        ?L197
?L196:
$DGL 0,2147
                CMP        currentkeyid,#0        ;                IF(currentkeyid!=#0)
                BNZ        $?L198
                BR        ?L199
?L198:
$DGL 0,2148
                set1        newkeypress        ;                  set1 newkeypress
$DGL 0,2149
                MOV        sendcodestate,#1        ;                  sendcodestate=#1
$DGL 0,2150
?L199:                                ;                ENDIF
$DGL 0,2151
                MOV        a,currentkeyid        ;                      lastkeyid=currentkeyid(a)       
                MOV        lastkeyid,a
$DGL 0,2152
                MOV        temporarycounter,#0        ;                      temporarycounter=#0
$DGL 0,2153
                MOVW        ax,#0        ;                      keydowncounter=#0(ax)
                MOVW        keydowncounter,ax
                BR        ?L200
$DGL 0,2154
?L197:                                ;              ELSE
$DGL 0,2155
                CMP        keyscantime,#5        ;                IF(keyscantime>=#5)
                BNC        $?L201
                BR        ?L202
?L201:
$DGL 0,2156
                MOV        keyscantime,#5        ;                   keyscantime=#5
$DGL 0,2157
                call        !longkey_press        ;                   call !longkey_press
$DGL 0,2158
?L202:                                ;                ENDIF
$DGL 0,2159
?L200:                                ;              ENDIF
                BR        ?L203
$DGL 0,2160
?L195:                                ;            ELSE
$DGL 0,2161
                MOV        a,currentkeyid        ;                    currentkeyidbak=currentkeyid(a)          
                MOV        currentkeyidbak,a
$DGL 0,2162
                MOV        keyscantime,#0        ;                    keyscantime=#0
$DGL 0,2163
                MOVW        ax,#0        ;                    keydowncounter=#0(ax)
                MOVW        keydowncounter,ax
$DGL 0,2164
?L203:                                ;            ENDIF
                BR        ?L204
$DGL 0,2165
?L193:                                ;        ELSE
$DGL 0,2166
                MOV        keyscantime,#0        ;                  keyscantime=#0
$DGL 0,2167
                MOVW        ax,#0        ;            keydowncounter=#0(ax)
                MOVW        keydowncounter,ax
$DGL 0,2168
                MOV        currentkeyid,#0        ;            currentkeyid=#0
$DGL 0,2169
?L204:                                ;  ENDIF
$DGL 0,2170
ret                                ;ret
   
$DGL 0,2172
keyscansub:                        ;keyscansub:
$DGL 0,2173
                MOV        keypressedcounter,#0        ;        keypressedcounter=#0
$DGL 0,2174
                MOV        currentkeyid,#0        ;        currentkeyid=#0
$DGL 0,2175
                MOV        PM0,#11111111B        ;  PM0=#11111111B            ;
$DGL 0,2176
                MOV        P0,#00000010B        ;  P0=#00000010B
  
$DGL 0,2178
                MOV        ADPC,#00000100B        ;  ADPC=#00000100B
$DGL 0,2179
                MOV        PM2,#11111101B        ;  PM2=#11111101B
$DGL 0,2180
                MOV        P2,#00001101B        ;  P2=#00001101B
  
$DGL 0,2182
                MOV        PM1,#00111111B        ;  PM1=#00111111B
$DGL 0,2183
                BF        learn_mode,$?L205        ;  if_bit(learn_mode)
$DGL 0,2184
                MOV        P1,#00111111B        ;      P1=#00111111B
                BR        ?L206
$DGL 0,2185
?L205:                                ;  else
$DGL 0,2186
                MOV        P1,#10111111B        ;      P1=#10111111B
$DGL 0,2187
?L206:                                ;  endif
  
$DGL 0,2189
                MOV        PM6,#11111111B        ;  PM6=#11111111B
$DGL 0,2190
                MOV        P6,#00000011B        ;  P6=#00000011B  
  
$DGL 0,2192
                clr1        pm6.1        ;  clr1 pm6.1
$DGL 0,2193
                clr1        p6.1        ;  clr1 p6.1
$DGL 0,2194
                call        !waitt        ;  call !waitt
$DGL 0,2195
                MOV        a,p12        ;  intp_reg12=p12(a)
                MOV        intp_reg12,a
$DGL 0,2196
                MOV        a,p3        ;  intp_reg3=p3(a)
                MOV        intp_reg3,a
$DGL 0,2197
                set1        p6.1        ;  set1 p6.1
  
$DGL 0,2199
                BT        intp_reg3.3,$?L207        ;  if_bit(!intp_reg3.3)
$DGL 0,2200
                MOV        currentkeyid,#1        ;    currentkeyid=#1
$DGL 0,2201
                BF        learn_mode,$?L208        ;    if_bit(learn_mode)                                                        
$DGL 0,2202
                MOV        currentkeyid,#51        ;            currentkeyid=#51
$DGL 0,2203
?L208:                                ;          endif
$DGL 0,2204
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2205
?L207:                                ;  endif
  
$DGL 0,2207
                BT        intp_reg12.0,$?L209        ;  if_bit(!intp_reg12.0)
$DGL 0,2208
                MOV        currentkeyid,#3        ;    currentkeyid=#3
$DGL 0,2209
                BF        learn_mode,$?L210        ;    if_bit(learn_mode)                                                        
$DGL 0,2210
                MOV        currentkeyid,#53        ;            currentkeyid=#53
$DGL 0,2211
?L210:                                ;          endif
$DGL 0,2212
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2213
?L209:                                ;  endif
  
$DGL 0,2215
                clr1        pm6.0        ;  clr1 pm6.0
$DGL 0,2216
                clr1        p6.0        ;  clr1 p6.0
$DGL 0,2217
                call        !waitt        ;  call !waitt
$DGL 0,2218
                MOV        a,p12        ;  intp_reg12=p12(a)
                MOV        intp_reg12,a
$DGL 0,2219
                MOV        a,p3        ;  intp_reg3=p3(a)
                MOV        intp_reg3,a
$DGL 0,2220
                set1        p6.0        ;  set1 p6.0
  
$DGL 0,2222
                BT        intp_reg3.3,$?L211        ;  if_bit(!intp_reg3.3)
$DGL 0,2223
                MOV        currentkeyid,#2        ;    currentkeyid=#2
$DGL 0,2224
                BF        learn_mode,$?L212        ;    if_bit(learn_mode)                                                        
$DGL 0,2225
                MOV        currentkeyid,#52        ;            currentkeyid=#52
$DGL 0,2226
?L212:                                ;          endif
$DGL 0,2227
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2228
?L211:                                ;  endif
  
$DGL 0,2230
                BT        intp_reg12.0,$?L213        ;  if_bit(!intp_reg12.0)
$DGL 0,2231
                MOV        currentkeyid,#4        ;    currentkeyid=#4
$DGL 0,2232
                BF        learn_mode,$?L214        ;    if_bit(learn_mode)                                                        
$DGL 0,2233
                MOV        currentkeyid,#54        ;            currentkeyid=#54
$DGL 0,2234
?L214:                                ;          endif
$DGL 0,2235
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2236
?L213:                                ;  endif
  
$DGL 0,2238
                clr1        pm2.2        ;  clr1 pm2.2
$DGL 0,2239
                clr1        p2.2        ;  clr1 p2.2
$DGL 0,2240
                call        !waitt        ;  call !waitt
$DGL 0,2241
                MOV        a,p12        ;  intp_reg12=p12(a)
                MOV        intp_reg12,a
$DGL 0,2242
                MOV        a,p3        ;  intp_reg3=p3(a)
                MOV        intp_reg3,a
$DGL 0,2243
                set1        p2.2        ;  set1 p2.2
  
$DGL 0,2245
                BT        intp_reg3.3,$?L215        ;  if_bit(!intp_reg3.3)
$DGL 0,2246
                MOV        currentkeyid,#8        ;    currentkeyid=#8
$DGL 0,2247
                BF        learn_mode,$?L216        ;    if_bit(learn_mode)                                                        
$DGL 0,2248
                MOV        currentkeyid,#58        ;            currentkeyid=#58
$DGL 0,2249
?L216:                                ;          endif
$DGL 0,2250
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2251
?L215:                                ;  endif
  
$DGL 0,2253
                BT        intp_reg12.0,$?L217        ;  if_bit(!intp_reg12.0)
$DGL 0,2254
                MOV        currentkeyid,#24        ;    currentkeyid=#24
$DGL 0,2255
                BF        learn_mode,$?L218        ;    if_bit(learn_mode)                                                        
$DGL 0,2256
                MOV        currentkeyid,#74        ;            currentkeyid=#74
$DGL 0,2257
?L218:                                ;          endif
$DGL 0,2258
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2259
?L217:                                ;  endif
  
$DGL 0,2261
                BT        intp_reg3.0,$?L219        ;  if_bit(!intp_reg3.0)
$DGL 0,2262
                MOV        currentkeyid,#34        ;    currentkeyid=#34
$DGL 0,2263
                BF        learn_mode,$?L220        ;    if_bit(learn_mode)                                                        
$DGL 0,2264
                MOV        currentkeyid,#84        ;            currentkeyid=#84
$DGL 0,2265
?L220:                                ;          endif
$DGL 0,2266
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2267
?L219:                                ;  endif
  
$DGL 0,2269
                BT        intp_reg3.1,$?L221        ;  if_bit(!intp_reg3.1)
$DGL 0,2270
                MOV        currentkeyid,#43        ;    currentkeyid=#43
$DGL 0,2271
                BF        learn_mode,$?L222        ;    if_bit(learn_mode)                                                        
$DGL 0,2272
                MOV        currentkeyid,#93        ;            currentkeyid=#93
$DGL 0,2273
?L222:                                ;          endif
$DGL 0,2274
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2275
?L221:                                ;  endif
  
$DGL 0,2277
                BT        intp_reg3.2,$?L223        ;  if_bit(!intp_reg3.2)
$DGL 0,2278
                MOV        currentkeyid,#102        ;          currentkeyid=#102
$DGL 0,2279
                INC        keypressedcounter        ;          keypressedcounter++
$DGL 0,2280
?L223:                                ;        endif
  
$DGL 0,2282
                clr1        pm0.1        ;  clr1 pm0.1
$DGL 0,2283
                clr1        p0.1        ;  clr1 p0.1
$DGL 0,2284
                call        !waitt        ;  call !waitt
$DGL 0,2285
                MOV        a,p12        ;  intp_reg12=p12(a)
                MOV        intp_reg12,a
$DGL 0,2286
                MOV        a,p3        ;  intp_reg3=p3(a)
                MOV        intp_reg3,a
$DGL 0,2287
                set1        p0.1        ;  set1 p0.1
  
$DGL 0,2289
                BT        intp_reg3.3,$?L224        ;  if_bit(!intp_reg3.3)
$DGL 0,2290
                MOV        currentkeyid,#6        ;    currentkeyid=#6
$DGL 0,2291
                BF        learn_mode,$?L225        ;    if_bit(learn_mode)                                                        
$DGL 0,2292
                MOV        currentkeyid,#56        ;            currentkeyid=#56
$DGL 0,2293
?L225:                                ;          endif
$DGL 0,2294
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2295
?L224:                                ;  endif
  
$DGL 0,2297
                BT        intp_reg12.0,$?L226        ;  if_bit(!intp_reg12.0)
$DGL 0,2298
                MOV        currentkeyid,#16        ;    currentkeyid=#16
$DGL 0,2299
                BF        learn_mode,$?L227        ;    if_bit(learn_mode)                                                        
$DGL 0,2300
                MOV        currentkeyid,#66        ;            currentkeyid=#66
$DGL 0,2301
?L227:                                ;          endif
$DGL 0,2302
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2303
?L226:                                ;  endif
  
$DGL 0,2305
                BT        intp_reg3.0,$?L228        ;  if_bit(!intp_reg3.0)
$DGL 0,2306
                MOV        currentkeyid,#26        ;    currentkeyid=#26
$DGL 0,2307
                BF        learn_mode,$?L229        ;    if_bit(learn_mode)                                                        
$DGL 0,2308
                MOV        currentkeyid,#76        ;            currentkeyid=#76
$DGL 0,2309
?L229:                                ;          endif
$DGL 0,2310
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2311
?L228:                                ;  endif
  
$DGL 0,2313
                BT        intp_reg3.1,$?L230        ;  if_bit(!intp_reg3.1)
$DGL 0,2314
                MOV        currentkeyid,#36        ;    currentkeyid=#36
$DGL 0,2315
                BF        learn_mode,$?L231        ;    if_bit(learn_mode)                                                        
$DGL 0,2316
                MOV        currentkeyid,#86        ;            currentkeyid=#86
$DGL 0,2317
?L231:                                ;          endif
$DGL 0,2318
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2319
?L230:                                ;  endif
  
$DGL 0,2321
                BT        intp_reg3.2,$?L232        ;  if_bit(!intp_reg3.2)
$DGL 0,2322
                MOV        currentkeyid,#101        ;          currentkeyid=#101
$DGL 0,2323
                INC        keypressedcounter        ;          keypressedcounter++
$DGL 0,2324
?L232:                                ;        endif
  
$DGL 0,2326
                clr1        pm2.0        ;  clr1 pm2.0
$DGL 0,2327
                clr1        p2.0        ;  clr1 p2.0
$DGL 0,2328
                call        !waitt        ;  call !waitt
$DGL 0,2329
                MOV        a,p12        ;  intp_reg12=p12(a)
                MOV        intp_reg12,a
$DGL 0,2330
                MOV        a,p3        ;  intp_reg3=p3(a)
                MOV        intp_reg3,a
$DGL 0,2331
                set1        p2.0        ;  set1 p2.0
  
$DGL 0,2333
                BT        intp_reg3.3,$?L233        ;  if_bit(!intp_reg3.3)
$DGL 0,2334
                MOV        currentkeyid,#7        ;    currentkeyid=#7
$DGL 0,2335
                BF        learn_mode,$?L234        ;    if_bit(learn_mode)                                                        
$DGL 0,2336
                MOV        currentkeyid,#57        ;            currentkeyid=#57
$DGL 0,2337
?L234:                                ;          endif
$DGL 0,2338
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2339
?L233:                                ;  endif
  
$DGL 0,2341
                BT        intp_reg12.0,$?L235        ;  if_bit(!intp_reg12.0)
$DGL 0,2342
                MOV        currentkeyid,#17        ;    currentkeyid=#17
$DGL 0,2343
                BF        learn_mode,$?L236        ;    if_bit(learn_mode)                                                        
$DGL 0,2344
                MOV        currentkeyid,#67        ;            currentkeyid=#67
$DGL 0,2345
?L236:                                ;          endif
$DGL 0,2346
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2347
?L235:                                ;  endif
  
$DGL 0,2349
                BT        intp_reg3.0,$?L237        ;  if_bit(!intp_reg3.0)
$DGL 0,2350
                MOV        currentkeyid,#27        ;    currentkeyid=#27
$DGL 0,2351
                BF        learn_mode,$?L238        ;    if_bit(learn_mode)                                                        
$DGL 0,2352
                MOV        currentkeyid,#77        ;            currentkeyid=#77
$DGL 0,2353
?L238:                                ;          endif
$DGL 0,2354
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2355
?L237:                                ;  endif
  
$DGL 0,2357
                BT        intp_reg3.1,$?L239        ;  if_bit(!intp_reg3.1)
$DGL 0,2358
                MOV        currentkeyid,#39        ;    currentkeyid=#39
$DGL 0,2359
                BF        learn_mode,$?L240        ;    if_bit(learn_mode)                                                        
$DGL 0,2360
                MOV        currentkeyid,#89        ;            currentkeyid=#89
$DGL 0,2361
?L240:                                ;          endif
$DGL 0,2362
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2363
?L239:                                ;  endif
  
$DGL 0,2365
                BT        intp_reg3.2,$?L241        ;  if_bit(!intp_reg3.2)
$DGL 0,2366
                MOV        currentkeyid,#47        ;    currentkeyid=#47
$DGL 0,2367
                BF        learn_mode,$?L242        ;    if_bit(learn_mode)                                                        
$DGL 0,2368
                MOV        currentkeyid,#97        ;            currentkeyid=#97
$DGL 0,2369
?L242:                                ;          endif
$DGL 0,2370
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2371
?L241:                                ;  endif
  
$DGL 0,2373
                clr1        pm2.3        ;  clr1 pm2.3
$DGL 0,2374
                clr1        p2.3        ;  clr1 p2.3
$DGL 0,2375
                call        !waitt        ;  call !waitt
$DGL 0,2376
                MOV        a,p12        ;  intp_reg12=p12(a)
                MOV        intp_reg12,a
$DGL 0,2377
                MOV        a,p3        ;  intp_reg3=p3(a)
                MOV        intp_reg3,a
$DGL 0,2378
                set1        p2.3        ;  set1 p2.3
  
$DGL 0,2380
                BT        intp_reg3.3,$?L243        ;  if_bit(!intp_reg3.3)
$DGL 0,2381
                MOV        currentkeyid,#5        ;    currentkeyid=#5
$DGL 0,2382
                BF        learn_mode,$?L244        ;    if_bit(learn_mode)                                                        
$DGL 0,2383
                MOV        currentkeyid,#55        ;            currentkeyid=#55
$DGL 0,2384
?L244:                                ;          endif
$DGL 0,2385
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2386
?L243:                                ;  endif
  
$DGL 0,2388
                BT        intp_reg12.0,$?L245        ;  if_bit(!intp_reg12.0)
$DGL 0,2389
                MOV        currentkeyid,#20        ;    currentkeyid=#20
$DGL 0,2390
                BF        learn_mode,$?L246        ;    if_bit(learn_mode)                                                        
$DGL 0,2391
                MOV        currentkeyid,#70        ;            currentkeyid=#70
$DGL 0,2392
?L246:                                ;          endif
$DGL 0,2393
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2394
?L245:                                ;  endif
  
$DGL 0,2396
                BT        intp_reg3.0,$?L247        ;  if_bit(!intp_reg3.0)
$DGL 0,2397
                MOV        currentkeyid,#30        ;    currentkeyid=#30
$DGL 0,2398
                BF        learn_mode,$?L248        ;    if_bit(learn_mode)                                                        
$DGL 0,2399
                MOV        currentkeyid,#80        ;            currentkeyid=#80
$DGL 0,2400
?L248:                                ;          endif
$DGL 0,2401
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2402
?L247:                                ;  endif
  
$DGL 0,2404
                BT        intp_reg3.1,$?L249        ;  if_bit(!intp_reg3.1)
$DGL 0,2405
                MOV        currentkeyid,#44        ;    currentkeyid=#44
$DGL 0,2406
                BF        learn_mode,$?L250        ;    if_bit(learn_mode)                                                        
$DGL 0,2407
                MOV        currentkeyid,#94        ;            currentkeyid=#94
$DGL 0,2408
?L250:                                ;          endif
$DGL 0,2409
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2410
?L249:                                ;  endif
  
$DGL 0,2412
                BT        intp_reg3.2,$?L251        ;  if_bit(!intp_reg3.2)
$DGL 0,2413
                MOV        currentkeyid,#48        ;    currentkeyid=#48
$DGL 0,2414
                BF        learn_mode,$?L252        ;    if_bit(learn_mode)                                                        
$DGL 0,2415
                MOV        currentkeyid,#98        ;            currentkeyid=#98
$DGL 0,2416
?L252:                                ;          endif
$DGL 0,2417
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2418
?L251:                                ;  endif
  
$DGL 0,2420
                clr1        pm1.5        ;  clr1 pm1.5
$DGL 0,2421
                clr1        p1.5        ;  clr1 p1.5
$DGL 0,2422
                call        !waitt        ;  call !waitt
$DGL 0,2423
                MOV        a,p12        ;  intp_reg12=p12(a)
                MOV        intp_reg12,a
$DGL 0,2424
                MOV        a,p3        ;  intp_reg3=p3(a)
                MOV        intp_reg3,a
$DGL 0,2425
                set1        p1.5        ;  set1 p1.5
  
$DGL 0,2427
                BT        intp_reg3.3,$?L253        ;  if_bit(!intp_reg3.3)
$DGL 0,2428
                MOV        currentkeyid,#11        ;    currentkeyid=#11
$DGL 0,2429
                BF        learn_mode,$?L254        ;    if_bit(learn_mode)                                                        
$DGL 0,2430
                MOV        currentkeyid,#61        ;            currentkeyid=#61
$DGL 0,2431
?L254:                                ;          endif
$DGL 0,2432
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2433
?L253:                                ;  endif
  
$DGL 0,2435
                BT        intp_reg12.0,$?L255        ;  if_bit(!intp_reg12.0)
$DGL 0,2436
                MOV        currentkeyid,#15        ;    currentkeyid=#15
$DGL 0,2437
                BF        learn_mode,$?L256        ;    if_bit(learn_mode)                                                        
$DGL 0,2438
                MOV        currentkeyid,#65        ;            currentkeyid=#65
$DGL 0,2439
?L256:                                ;          endif
$DGL 0,2440
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2441
?L255:                                ;  endif
  
$DGL 0,2443
                BT        intp_reg3.0,$?L257        ;  if_bit(!intp_reg3.0)
$DGL 0,2444
                MOV        currentkeyid,#28        ;    currentkeyid=#28
$DGL 0,2445
                BF        learn_mode,$?L258        ;    if_bit(learn_mode)                                                        
$DGL 0,2446
                MOV        currentkeyid,#78        ;            currentkeyid=#78
$DGL 0,2447
?L258:                                ;          endif
$DGL 0,2448
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2449
?L257:                                ;  endif
  
$DGL 0,2451
                BT        intp_reg3.1,$?L259        ;  if_bit(!intp_reg3.1)
$DGL 0,2452
                MOV        currentkeyid,#42        ;    currentkeyid=#42
$DGL 0,2453
                BF        learn_mode,$?L260        ;    if_bit(learn_mode)                                                        
$DGL 0,2454
                MOV        currentkeyid,#92        ;            currentkeyid=#92
$DGL 0,2455
?L260:                                ;          endif
$DGL 0,2456
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2457
?L259:                                ;  endif
  
$DGL 0,2459
                BT        intp_reg3.2,$?L261        ;  if_bit(!intp_reg3.2)
$DGL 0,2460
                MOV        currentkeyid,#46        ;    currentkeyid=#46
$DGL 0,2461
                BF        learn_mode,$?L262        ;    if_bit(learn_mode)                                                        
$DGL 0,2462
                MOV        currentkeyid,#96        ;            currentkeyid=#96
$DGL 0,2463
?L262:                                ;          endif
$DGL 0,2464
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2465
?L261:                                ;  endif
  
$DGL 0,2467
                clr1        pm1.4        ;  clr1 pm1.4
$DGL 0,2468
                clr1        p1.4        ;  clr1 p1.4
$DGL 0,2469
                call        !waitt        ;  call !waitt
$DGL 0,2470
                MOV        a,p12        ;  intp_reg12=p12(a)
                MOV        intp_reg12,a
$DGL 0,2471
                MOV        a,p3        ;  intp_reg3=p3(a)
                MOV        intp_reg3,a
$DGL 0,2472
                set1        p1.4        ;  set1 p1.4
  
$DGL 0,2474
                BT        intp_reg3.3,$?L263        ;  if_bit(!intp_reg3.3)
$DGL 0,2475
                MOV        currentkeyid,#14        ;    currentkeyid=#14
$DGL 0,2476
                BF        learn_mode,$?L264        ;    if_bit(learn_mode)                                                        
$DGL 0,2477
                MOV        currentkeyid,#64        ;            currentkeyid=#64
$DGL 0,2478
?L264:                                ;          endif
$DGL 0,2479
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2480
?L263:                                ;  endif
  
$DGL 0,2482
                BT        intp_reg12.0,$?L265        ;  if_bit(!intp_reg12.0)
$DGL 0,2483
                MOV        currentkeyid,#19        ;    currentkeyid=#19
$DGL 0,2484
                BF        learn_mode,$?L266        ;    if_bit(learn_mode)                                                        
$DGL 0,2485
                MOV        currentkeyid,#69        ;            currentkeyid=#69
$DGL 0,2486
?L266:                                ;          endif
$DGL 0,2487
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2488
?L265:                                ;  endif
  
$DGL 0,2490
                BT        intp_reg3.0,$?L267        ;  if_bit(!intp_reg3.0)
$DGL 0,2491
                MOV        currentkeyid,#25        ;    currentkeyid=#25
$DGL 0,2492
                BF        learn_mode,$?L268        ;    if_bit(learn_mode)                                                        
$DGL 0,2493
                MOV        currentkeyid,#75        ;            currentkeyid=#75
$DGL 0,2494
?L268:                                ;          endif
$DGL 0,2495
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2496
?L267:                                ;  endif
  
$DGL 0,2498
                BT        intp_reg3.1,$?L269        ;  if_bit(!intp_reg3.1)
$DGL 0,2499
                MOV        currentkeyid,#38        ;    currentkeyid=#38
$DGL 0,2500
                BF        learn_mode,$?L270        ;    if_bit(learn_mode)                                                        
$DGL 0,2501
                MOV        currentkeyid,#88        ;            currentkeyid=#88
$DGL 0,2502
?L270:                                ;          endif
$DGL 0,2503
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2504
?L269:                                ;  endif
  
$DGL 0,2506
                BT        intp_reg3.2,$?L271        ;  if_bit(!intp_reg3.2)
$DGL 0,2507
                MOV        currentkeyid,#50        ;    currentkeyid=#50
$DGL 0,2508
                BF        learn_mode,$?L272        ;    if_bit(learn_mode)                                                        
$DGL 0,2509
                MOV        currentkeyid,#100        ;            currentkeyid=#100
$DGL 0,2510
?L272:                                ;          endif
$DGL 0,2511
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2512
?L271:                                ;  endif
  
$DGL 0,2514
                clr1        pm1.3        ;  clr1 pm1.3
$DGL 0,2515
                clr1        p1.3        ;  clr1 p1.3
$DGL 0,2516
                call        !waitt        ;  call !waitt
$DGL 0,2517
                MOV        a,p12        ;  intp_reg12=p12(a)
                MOV        intp_reg12,a
$DGL 0,2518
                MOV        a,p3        ;  intp_reg3=p3(a)
                MOV        intp_reg3,a
$DGL 0,2519
                set1        p1.3        ;  set1 p1.3
  
$DGL 0,2521
                BT        intp_reg3.3,$?L273        ;  if_bit(!intp_reg3.3)
$DGL 0,2522
                MOV        currentkeyid,#10        ;    currentkeyid=#10
$DGL 0,2523
                BF        learn_mode,$?L274        ;    if_bit(learn_mode)                                                        
$DGL 0,2524
                MOV        currentkeyid,#60        ;            currentkeyid=#60
$DGL 0,2525
?L274:                                ;          endif
$DGL 0,2526
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2527
?L273:                                ;  endif
  
$DGL 0,2529
                BT        intp_reg12.0,$?L275        ;  if_bit(!intp_reg12.0)
$DGL 0,2530
                MOV        currentkeyid,#22        ;    currentkeyid=#22
$DGL 0,2531
                BF        learn_mode,$?L276        ;    if_bit(learn_mode)                                                        
$DGL 0,2532
                MOV        currentkeyid,#72        ;            currentkeyid=#72
$DGL 0,2533
?L276:                                ;          endif
$DGL 0,2534
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2535
?L275:                                ;  endif
  
$DGL 0,2537
                BT        intp_reg3.0,$?L277        ;  if_bit(!intp_reg3.0)
$DGL 0,2538
                MOV        currentkeyid,#32        ;    currentkeyid=#32
$DGL 0,2539
                BF        learn_mode,$?L278        ;    if_bit(learn_mode)                                                        
$DGL 0,2540
                MOV        currentkeyid,#82        ;            currentkeyid=#82
$DGL 0,2541
?L278:                                ;          endif
$DGL 0,2542
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2543
?L277:                                ;  endif
  
$DGL 0,2545
                BT        intp_reg3.1,$?L279        ;  if_bit(!intp_reg3.1)
$DGL 0,2546
                MOV        currentkeyid,#35        ;    currentkeyid=#35
$DGL 0,2547
                BF        learn_mode,$?L280        ;    if_bit(learn_mode)                                                        
$DGL 0,2548
                MOV        currentkeyid,#85        ;            currentkeyid=#85
$DGL 0,2549
?L280:                                ;          endif
$DGL 0,2550
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2551
?L279:                                ;  endif
  
$DGL 0,2553
                BT        intp_reg3.2,$?L281        ;  if_bit(!intp_reg3.2)
$DGL 0,2554
                MOV        currentkeyid,#104        ;          currentkeyid=#104
$DGL 0,2555
                INC        keypressedcounter        ;          keypressedcounter++
$DGL 0,2556
?L281:                                ;        endif
  
$DGL 0,2558
                clr1        pm1.2        ;  clr1 pm1.2
$DGL 0,2559
                clr1        p1.2        ;  clr1 p1.2
$DGL 0,2560
                call        !waitt        ;  call !waitt
$DGL 0,2561
                MOV        a,p12        ;  intp_reg12=p12(a)
                MOV        intp_reg12,a
$DGL 0,2562
                MOV        a,p3        ;  intp_reg3=p3(a)
                MOV        intp_reg3,a
$DGL 0,2563
                set1        p1.2        ;  set1 p1.2
  
$DGL 0,2565
                BT        intp_reg3.3,$?L282        ;  if_bit(!intp_reg3.3)
$DGL 0,2566
                MOV        currentkeyid,#13        ;    currentkeyid=#13
$DGL 0,2567
                BF        learn_mode,$?L283        ;    if_bit(learn_mode)                                                        
$DGL 0,2568
                MOV        currentkeyid,#63        ;            currentkeyid=#63
$DGL 0,2569
?L283:                                ;          endif
$DGL 0,2570
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2571
?L282:                                ;  endif
  
$DGL 0,2573
                BT        intp_reg12.0,$?L284        ;  if_bit(!intp_reg12.0)
$DGL 0,2574
                MOV        currentkeyid,#18        ;    currentkeyid=#18
$DGL 0,2575
                BF        learn_mode,$?L285        ;    if_bit(learn_mode)                                                        
$DGL 0,2576
                MOV        currentkeyid,#68        ;            currentkeyid=#68
$DGL 0,2577
?L285:                                ;          endif
$DGL 0,2578
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2579
?L284:                                ;  endif
  
$DGL 0,2581
                BT        intp_reg3.0,$?L286        ;  if_bit(!intp_reg3.0)
$DGL 0,2582
                MOV        currentkeyid,#29        ;    currentkeyid=#29
$DGL 0,2583
                BF        learn_mode,$?L287        ;    if_bit(learn_mode)                                                        
$DGL 0,2584
                MOV        currentkeyid,#79        ;            currentkeyid=#79
$DGL 0,2585
?L287:                                ;          endif
$DGL 0,2586
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2587
?L286:                                ;  endif
  
$DGL 0,2589
                BT        intp_reg3.1,$?L288        ;  if_bit(!intp_reg3.1)
$DGL 0,2590
                MOV        currentkeyid,#41        ;    currentkeyid=#41
$DGL 0,2591
                BF        learn_mode,$?L289        ;    if_bit(learn_mode)                                                        
$DGL 0,2592
                MOV        currentkeyid,#91        ;            currentkeyid=#91
$DGL 0,2593
?L289:                                ;          endif
$DGL 0,2594
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2595
?L288:                                ;  endif
  
$DGL 0,2597
                BT        intp_reg3.2,$?L290        ;  if_bit(!intp_reg3.2)
$DGL 0,2598
                MOV        currentkeyid,#45        ;    currentkeyid=#45
$DGL 0,2599
                BF        learn_mode,$?L291        ;    if_bit(learn_mode)                                                        
$DGL 0,2600
                MOV        currentkeyid,#95        ;            currentkeyid=#95
$DGL 0,2601
?L291:                                ;          endif
$DGL 0,2602
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2603
?L290:                                ;  endif
  
$DGL 0,2605
                clr1        pm1.1        ;  clr1 pm1.1
$DGL 0,2606
                clr1        p1.1        ;  clr1 p1.1
$DGL 0,2607
                call        !waitt        ;  call !waitt
$DGL 0,2608
                MOV        a,p12        ;  intp_reg12=p12(a)
                MOV        intp_reg12,a
$DGL 0,2609
                MOV        a,p3        ;  intp_reg3=p3(a)
                MOV        intp_reg3,a
$DGL 0,2610
                set1        p1.1        ;  set1 p1.1
  
$DGL 0,2612
                BT        intp_reg3.3,$?L292        ;  if_bit(!intp_reg3.3)
$DGL 0,2613
                MOV        currentkeyid,#9        ;    currentkeyid=#9
$DGL 0,2614
                BF        learn_mode,$?L293        ;    if_bit(learn_mode)                                                        
$DGL 0,2615
                MOV        currentkeyid,#59        ;            currentkeyid=#59
$DGL 0,2616
?L293:                                ;          endif
$DGL 0,2617
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2618
?L292:                                ;  endif
  
$DGL 0,2620
                BT        intp_reg12.0,$?L294        ;  if_bit(!intp_reg12.0)
$DGL 0,2621
                MOV        currentkeyid,#23        ;    currentkeyid=#23
$DGL 0,2622
                BF        learn_mode,$?L295        ;    if_bit(learn_mode)                                                        
$DGL 0,2623
                MOV        currentkeyid,#73        ;            currentkeyid=#73
$DGL 0,2624
?L295:                                ;          endif
$DGL 0,2625
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2626
?L294:                                ;  endif
  
$DGL 0,2628
                BT        intp_reg3.0,$?L296        ;  if_bit(!intp_reg3.0)
$DGL 0,2629
                MOV        currentkeyid,#31        ;    currentkeyid=#31
$DGL 0,2630
                BF        learn_mode,$?L297        ;    if_bit(learn_mode)                                                        
$DGL 0,2631
                MOV        currentkeyid,#81        ;            currentkeyid=#81
$DGL 0,2632
?L297:                                ;          endif
$DGL 0,2633
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2634
?L296:                                ;  endif
  
$DGL 0,2636
                BT        intp_reg3.1,$?L298        ;  if_bit(!intp_reg3.1)
$DGL 0,2637
                MOV        currentkeyid,#37        ;    currentkeyid=#37
$DGL 0,2638
                BF        learn_mode,$?L299        ;    if_bit(learn_mode)                                                        
$DGL 0,2639
                MOV        currentkeyid,#87        ;            currentkeyid=#87
$DGL 0,2640
?L299:                                ;          endif
$DGL 0,2641
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2642
?L298:                                ;  endif
  
$DGL 0,2644
                BT        intp_reg3.2,$?L300        ;  if_bit(!intp_reg3.2)
$DGL 0,2645
                MOV        currentkeyid,#49        ;    currentkeyid=#49
$DGL 0,2646
                BF        learn_mode,$?L301        ;    if_bit(learn_mode)                                                        
$DGL 0,2647
                MOV        currentkeyid,#99        ;            currentkeyid=#99
$DGL 0,2648
?L301:                                ;          endif
$DGL 0,2649
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2650
?L300:                                ;  endif
  
$DGL 0,2652
                clr1        pm1.0        ;  clr1 pm1.0
$DGL 0,2653
                clr1        p1.0        ;  clr1 p1.0
$DGL 0,2654
                call        !waitt        ;  call !waitt
$DGL 0,2655
                MOV        a,p12        ;  intp_reg12=p12(a)
                MOV        intp_reg12,a
$DGL 0,2656
                MOV        a,p3        ;  intp_reg3=p3(a)
                MOV        intp_reg3,a
$DGL 0,2657
                set1        p1.0        ;  set1 p1.0
  
$DGL 0,2659
                BT        intp_reg3.3,$?L302        ;  if_bit(!intp_reg3.3)
$DGL 0,2660
                MOV        currentkeyid,#12        ;    currentkeyid=#12
$DGL 0,2661
                BF        learn_mode,$?L303        ;    if_bit(learn_mode)                                                        
$DGL 0,2662
                MOV        currentkeyid,#62        ;            currentkeyid=#62
$DGL 0,2663
?L303:                                ;          endif
$DGL 0,2664
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2665
?L302:                                ;  endif
  
$DGL 0,2667
                BT        intp_reg12.0,$?L304        ;  if_bit(!intp_reg12.0)
$DGL 0,2668
                MOV        currentkeyid,#21        ;    currentkeyid=#21
$DGL 0,2669
                BF        learn_mode,$?L305        ;    if_bit(learn_mode)                                                        
$DGL 0,2670
                MOV        currentkeyid,#71        ;            currentkeyid=#71
$DGL 0,2671
?L305:                                ;          endif
$DGL 0,2672
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2673
?L304:                                ;  endif
  
$DGL 0,2675
                BT        intp_reg3.0,$?L306        ;  if_bit(!intp_reg3.0)
$DGL 0,2676
                MOV        currentkeyid,#33        ;    currentkeyid=#33
$DGL 0,2677
                BF        learn_mode,$?L307        ;    if_bit(learn_mode)                                                        
$DGL 0,2678
                MOV        currentkeyid,#83        ;            currentkeyid=#83
$DGL 0,2679
?L307:                                ;          endif
$DGL 0,2680
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2681
?L306:                                ;  endif
  
$DGL 0,2683
                BT        intp_reg3.1,$?L308        ;  if_bit(!intp_reg3.1)
$DGL 0,2684
                MOV        currentkeyid,#40        ;    currentkeyid=#40
$DGL 0,2685
                BF        learn_mode,$?L309        ;    if_bit(learn_mode)                                                        
$DGL 0,2686
                MOV        currentkeyid,#90        ;            currentkeyid=#90
$DGL 0,2687
?L309:                                ;          endif
$DGL 0,2688
                INC        keypressedcounter        ;    keypressedcounter++
$DGL 0,2689
?L308:                                ;  endif
  
$DGL 0,2691
                BT        intp_reg3.2,$?L310        ;  if_bit(!intp_reg3.2)
$DGL 0,2692
                MOV        currentkeyid,#103        ;          currentkeyid=#103
$DGL 0,2693
                INC        keypressedcounter        ;          keypressedcounter++
$DGL 0,2694
?L310:                                ;        endif
$DGL 0,2695
ret                                ;ret
$DGL 0,2696
waitt:                                ;waitt:
$DGL 0,2697
                call        !wait        ;        call !wait
$DGL 0,2698
                call        !wait        ;        call !wait
$DGL 0,2699
                call        !wait        ;        call !wait
$DGL 0,2700
                call        !wait        ;        call !wait
$DGL 0,2701
                call        !wait        ;        call !wait
$DGL 0,2702
                call        !wait        ;        call !wait
$DGL 0,2703
                call        !wait        ;        call !wait
$DGL 0,2704
                call        !wait        ;        call !wait
$DGL 0,2705
                call        !wait        ;        call !wait
$DGL 0,2706
                call        !wait        ;        call !wait
$DGL 0,2707
                call        !wait        ;        call !wait
$DGL 0,2708
                call        !wait        ;        call !wait
$DGL 0,2709
                call        !wait        ;        call !wait
$DGL 0,2710
                call        !wait        ;        call !wait
$DGL 0,2711
                call        !wait        ;        call !wait
$DGL 0,2712
                call        !wait        ;        call !wait
$DGL 0,2713
                call        !wait        ;        call !wait
$DGL 0,2714
                call        !wait        ;        call !wait
$DGL 0,2715
                call        !wait        ;        call !wait
$DGL 0,2716
                call        !wait        ;        call !wait
$DGL 0,2717
                ret                ;        ret
  
$DGL 0,2719
longkey_press:                        ;longkey_press:
$DGL 0,2720
                MOVW        ax,keydowncounter        ;     ax=keydowncounter
$DGL 0,2721
                INCW        ax        ;     ax++
$DGL 0,2722
                MOVW        keydowncounter,ax        ;     keydowncounter=ax
$DGL 0,2723
                CMP        currentkeyid,#50        ;     if(currentkeyid<=#50)
                BZ        $$+4
                BNC        $?L311
$DGL 0,2724
                CMP        curdevstate,#0        ;       if(curdevstate==#0)
                BNZ        $?L312
$DGL 0,2725
                MOVW        ax,keydowncounter        ;        if(keydowncounter==#7)(ax)      ;媦檸箾煈閸幩檸覎駤c泿謱幉戦泿瑤鈾幰帋疀幹寧矐闆幀庘媍弾迱闂帹108ms
                CMPW        ax,#7
                BNZ        $?L313
$DGL 0,2726
                MOV        WDTE,#0ACH        ;          WDTE=#0ACH
$DGL 0,2727
                MOV        temporarycounter,#0        ;          temporarycounter=#0
$DGL 0,2728
                set1        newkeypress        ;          set1 newkeypress
$DGL 0,2729
                MOV        sendcodestate,#2        ;          sendcodestate=#2
$DGL 0,2730
                ret                ;          ret
                BR        ?L314
$DGL 0,2731
?L313:                                ;        else
$DGL 0,2732
                MOVW        ax,keydowncounter        ;          if(keydowncounter>=#8)(ax)
                CMPW        ax,#8
                BC        $?L315
$DGL 0,2733
                MOV        WDTE,#0ACH        ;            WDTE=#0ACH
$DGL 0,2734
                MOV        keydowncounter,#8        ;            keydowncounter=#8
$DGL 0,2735
                INC        temporarycounter        ;            temporarycounter++
$DGL 0,2736
                CMP        temporarycounter,#7        ;            if(temporarycounter>=#7)    ;泿謱幉戦泿瑤鈰c弾迱闂帹108ms
                BC        $?L316
$DGL 0,2737
                MOV        WDTE,#0ACH        ;             WDTE=#0ACH
$DGL 0,2738
                MOV        temporarycounter,#0        ;             temporarycounter=#0
$DGL 0,2739
                set1        newkeypress        ;             set1 newkeypress
$DGL 0,2740
                MOV        sendcodestate,#2        ;             sendcodestate=#2
$DGL 0,2741
?L316:                                ;            endif
$DGL 0,2742
?L315:                                ;          endif
$DGL 0,2743
?L314:                                ;        endif
$DGL 0,2744
?L312:                                ;       endif
$DGL 0,2745
?L311:                                ;     endif
$DGL 0,2746
                CMP        currentkeyid,#100        ;     if(currentkeyid>#100)
                BZ        $?L317
                BC        $?L317
$DGL 0,2747
                MOVW        ax,keydowncounter        ;       if(keydowncounter>=#192)(ax)
                CMPW        ax,#192
                BC        $?L318
$DGL 0,2748
                MOV        a,currentkeyid        ;         a=currentkeyid
$DGL 0,2749
                                ;         switch(a)
$DGL 0,2750
                CMP        a,#101        ;         case 101:
                BNZ        $?L319
$DGL 0,2751
                set1        tmmk50        ;           set1 tmmk50
$DGL 0,2752
                MOV        currentkeyid,#105        ;           currentkeyid=#105
$DGL 0,2753
                MOV        lastkeyid,#105        ;           lastkeyid=#105
$DGL 0,2754
                clr1        switchkey        ;           clr1 switchkey
$DGL 0,2755
                set1        newkeypress        ;           set1 newkeypress
$DGL 0,2756
                MOV        sendcodestate,#0        ;           sendcodestate=#0
$DGL 0,2757
                BR        ?L320        ;         break
$DGL 0,2758
?L319:                                ;         case 102:
                CMP        a,#102
                BNZ        $?L321
$DGL 0,2759
                set1        tmmk50        ;           set1 tmmk50
$DGL 0,2760
                MOV        currentkeyid,#106        ;           currentkeyid=#106
$DGL 0,2761
                MOV        lastkeyid,#106        ;           lastkeyid=#106
$DGL 0,2762
                clr1        switchkey        ;           clr1 switchkey
$DGL 0,2763
                set1        newkeypress        ;           set1 newkeypress
$DGL 0,2764
                MOV        sendcodestate,#1        ;           sendcodestate=#1
$DGL 0,2765
                BR        ?L320        ;         break
$DGL 0,2766
?L321:                                ;         case 103:
                CMP        a,#103
                BNZ        $?L322
$DGL 0,2767
                set1        tmmk50        ;           set1 tmmk50
$DGL 0,2768
                MOV        currentkeyid,#107        ;           currentkeyid=#107
$DGL 0,2769
                MOV        lastkeyid,#107        ;           lastkeyid=#107
$DGL 0,2770
                clr1        switchkey        ;           clr1 switchkey
$DGL 0,2771
                set1        newkeypress        ;           set1 newkeypress
$DGL 0,2772
                MOV        sendcodestate,#2        ;           sendcodestate=#2
$DGL 0,2773
                BR        ?L320        ;         break
$DGL 0,2774
?L322:                                ;         case 104:
                CMP        a,#104
                BNZ        $?L323
$DGL 0,2775
                set1        tmmk50        ;           set1 tmmk50
$DGL 0,2776
                MOV        currentkeyid,#108        ;           currentkeyid=#108
$DGL 0,2777
                MOV        lastkeyid,#108        ;           lastkeyid=#108
$DGL 0,2778
                clr1        switchkey        ;           clr1 switchkey
$DGL 0,2779
                set1        newkeypress        ;           set1 newkeypress
$DGL 0,2780
                MOV        sendcodestate,#3        ;           sendcodestate=#3
$DGL 0,2781
                BR        ?L320        ;         break
$DGL 0,2782
?L323:                                ;         default:
$DGL 0,2783
?L320:                                ;         ends
$DGL 0,2784
                MOVW        ax,#0        ;         keydowncounter=#0(ax)   
                MOVW        keydowncounter,ax
$DGL 0,2785
?L318:                                ;       endif
$DGL 0,2786
?L317:                                ;     endif
$DGL 0,2787
ret                                ;ret

$DGL 0,2789
wait:                                ;wait:
$DGL 0,2790
                nop                ;  nop
$DGL 0,2791
                nop                ;        nop
$DGL 0,2792
                nop                ;        nop
$DGL 0,2793
                nop                ;        nop
$DGL 0,2794
                nop                ;        nop
$DGL 0,2795
                nop                ;        nop
$DGL 0,2796
                nop                ;        nop
$DGL 0,2797
                nop                ;        nop
$DGL 0,2798
                nop                ;        nop
$DGL 0,2799
                nop                ;        nop
$DGL 0,2800
ret                                ;ret
       
$DGL 0,2802
keyprocess:                        ;keyprocess:
$DGL 0,2803
                MOV        WDTE,#0ACH        ;   WDTE=#0ACH
$DGL 0,2804
                BT        newkeypress,$?L324        ;   if_bit(!newkeypress)
$DGL 0,2805
                ret                ;     ret
$DGL 0,2806
?L324:                                ;   endif
$DGL 0,2807
                clr1        newkeypress        ;   clr1 newkeypress
$DGL 0,2808
                MOV        a,lastkeyid        ;   lastkeyidbak=lastkeyid(a)
                MOV        lastkeyidbak,a
$DGL 0,2809
                MOV        a,lastkeyidbak        ;     if(lastkeyidbak<=#50)(a)
                CMP        a,#50
                BZ        $$+4
                BNC        $?L325
$DGL 0,2810
                CMP        curdevstate,#0        ;       if(curdevstate==#0)
                BNZ        $?L326
$DGL 0,2811
                call        !search_codebuffer        ;          call !search_codebuffer
                BR        ?L327
$DGL 0,2812
?L326:                                ;       else
$DGL 0,2813
                call        !block_switch        ;          call !block_switch
$DGL 0,2814
                MOV        a,lastkeyidbak        ;          a=lastkeyidbak
$DGL 0,2815
                MOV        datanumber,a        ;          datanumber=a
$DGL 0,2816
                set1        learn_send        ;          set1 learn_send
$DGL 0,2817
                call        !learn_pro        ;          call !learn_pro
$DGL 0,2818
?L327:                                ;       endif
$DGL 0,2819
                set1        keypro_end        ;       set1 keypro_end
$DGL 0,2820
                ret                ;       ret
$DGL 0,2821
?L325:                                ;     endif
$DGL 0,2822
                MOV        a,lastkeyidbak        ;     if(lastkeyidbak<=#100)(a)
                CMP        a,#100
                BZ        $$+4
                BNC        $?L328
$DGL 0,2823
                MOV        a,lastkeyidbak        ;          a=lastkeyidbak
$DGL 0,2824
                clr1        cy        ;          clr1 cy
$DGL 0,2825
                subc        a,#50        ;          subc a,#50
$DGL 0,2826
                MOV        datanumber,a        ;          datanumber=a
$DGL 0,2827
                MOV        lastkeyidbak,a        ;          lastkeyidbak=a
$DGL 0,2828
                call        !block_switch        ;          call !block_switch
$DGL 0,2829
                set1        nosendcode        ;          set1 nosendcode
$DGL 0,2830
                set1        enable_learn        ;          set1 enable_learn
                BR        ?L329
$DGL 0,2831
?L328:                                ;     else
$DGL 0,2832
                MOV        a,lastkeyidbak        ;       a=lastkeyidbak
$DGL 0,2833
                                ;       switch(a)
$DGL 0,2834
                CMP        a,#101        ;       case 101:
                BNZ        $?L330
$DGL 0,2835
                MOV        sendcodestate,#0        ;         sendcodestate=#0
$DGL 0,2836
                set1        switchkey        ;         set1 switchkey
$DGL 0,2837
                MOV        curdevstate,#0        ;         curdevstate=#0
$DGL 0,2838
                BR        ?L331        ;       break
$DGL 0,2839
?L330:                                ;       case 102:
                CMP        a,#102
                BNZ        $?L332
$DGL 0,2840
                MOV        sendcodestate,#0        ;         sendcodestate=#0
$DGL 0,2841
                set1        switchkey        ;         set1 switchkey
$DGL 0,2842
                MOV        curdevstate,#1        ;         curdevstate=#1
$DGL 0,2843
                BR        ?L331        ;       break
$DGL 0,2844
?L332:                                ;       case 103:
                CMP        a,#103
                BNZ        $?L333
$DGL 0,2845
                MOV        sendcodestate,#0        ;         sendcodestate=#0
$DGL 0,2846
                set1        switchkey        ;         set1 switchkey
$DGL 0,2847
                MOV        curdevstate,#2        ;         curdevstate=#2
$DGL 0,2848
                BR        ?L331        ;       break
$DGL 0,2849
?L333:                                ;       case 104:
                CMP        a,#104
                BNZ        $?L334
$DGL 0,2850
                MOV        sendcodestate,#0        ;         sendcodestate=#0
$DGL 0,2851
                set1        switchkey        ;         set1 switchkey
$DGL 0,2852
                MOV        curdevstate,#3        ;         curdevstate=#3
$DGL 0,2853
                BR        ?L331        ;       break
$DGL 0,2854
?L334:                                ;       case 105:
                CMP        a,#105
                BNZ        $?L335
$DGL 0,2855
                MOV        sendcodestate,#0        ;         sendcodestate=#0
$DGL 0,2856
                set1        switchkey        ;         set1 switchkey
$DGL 0,2857
                MOV        curdevstate,#0        ;         curdevstate=#0
$DGL 0,2858
                BR        ?L331        ;       break
$DGL 0,2859
?L335:                                ;       case 106:
                CMP        a,#106
                BNZ        $?L336
$DGL 0,2860
                MOV        sendcodestate,#0        ;         sendcodestate=#0
$DGL 0,2861
                set1        learn_mode        ;         set1 learn_mode
$DGL 0,2862
                MOV        curdevstate,#1        ;         curdevstate=#1
$DGL 0,2863
                MOV        WDTE,#0ACH        ;         WDTE=#0ACH
$DGL 0,2864
                call        !learn_sub        ;         call !learn_sub
$DGL 0,2865
                MOV        WDTE,#0ACH        ;         WDTE=#0ACH
$DGL 0,2866
                BR        ?L331        ;       break
$DGL 0,2867
?L336:                                ;       case 107:
                CMP        a,#107
                BNZ        $?L337
$DGL 0,2868
                MOV        sendcodestate,#0        ;         sendcodestate=#0
$DGL 0,2869
                set1        learn_mode        ;         set1 learn_mode
$DGL 0,2870
                MOV        curdevstate,#2        ;         curdevstate=#2
$DGL 0,2871
                MOV        WDTE,#0ACH        ;         WDTE=#0ACH
$DGL 0,2872
                call        !learn_sub        ;         call !learn_sub
$DGL 0,2873
                MOV        WDTE,#0ACH        ;         WDTE=#0ACH
$DGL 0,2874
                BR        ?L331        ;       break
$DGL 0,2875
?L337:                                ;       case 108:
                CMP        a,#108
                BNZ        $?L338
$DGL 0,2876
                MOV        sendcodestate,#0        ;         sendcodestate=#0
$DGL 0,2877
                set1        learn_mode        ;         set1 learn_mode
$DGL 0,2878
                MOV        curdevstate,#3        ;         curdevstate=#3
$DGL 0,2879
                MOV        WDTE,#0ACH        ;         WDTE=#0ACH
$DGL 0,2880
                call        !learn_sub        ;         call !learn_sub
$DGL 0,2881
                MOV        WDTE,#0ACH        ;         WDTE=#0ACH
$DGL 0,2882
                BR        ?L331        ;       break
$DGL 0,2883
?L338:                                ;       default:
$DGL 0,2884
?L331:                                ;       ends
$DGL 0,2885
?L329:                                ;     endif
$DGL 0,2886
                set1        keypro_end        ;     set1 keypro_end
$DGL 0,2887
                MOV        WDTE,#0ACH        ;     WDTE=#0ACH  
$DGL 0,2888
ret                                ;ret

$DGL 0,2890
search_codebuffer:                ;search_codebuffer:
$DGL 0,2891
                MOV        WDTE,#0ACH        ;     WDTE=#0ACH
$DGL 0,2892
                MOV        a,lastkeyidbak        ;     a=lastkeyidbak
$DGL 0,2893
                DEC        a        ;     a--
$DGL 0,2894
                MOV        b,a        ;     b=a
$DGL 0,2895
                MOVW        hl,#codebuffer_tab        ;     hl=#codebuffer_tab
$DGL 0,2896
                MOV        a,[hl+b]        ;     codebuffer=[hl+b](a)
                MOV        codebuffer,a
$DGL 0,2897
ret                                ;ret

$DGL 0,2899
codebuffer_tab:                        ;codebuffer_tab:
$DGL 0,2900
                db        00000000b        ;     db 00000000b
$DGL 0,2901
                db        00000001b        ;     db 00000001b
$DGL 0,2902
                db        00000010b        ;     db 00000010b
$DGL 0,2903
                db        00000011b        ;     db 00000011b
$DGL 0,2904
                db        00000100b        ;     db 00000100b
$DGL 0,2905
                db        00000101b        ;     db 00000101b
$DGL 0,2906
                db        00000110b        ;     db 00000110b
$DGL 0,2907
                db        00000111b        ;     db 00000111b
$DGL 0,2908
                db        00001000b        ;     db 00001000b
$DGL 0,2909
                db        00001001b        ;     db 00001001b
$DGL 0,2910
                db        00001010b        ;     db 00001010b
$DGL 0,2911
                db        00001011b        ;     db 00001011b
$DGL 0,2912
                db        00001100b        ;     db 00001100b
$DGL 0,2913
                db        00001101b        ;     db 00001101b
$DGL 0,2914
                db        00001110b        ;     db 00001110b
$DGL 0,2915
                db        00001111b        ;     db 00001111b
$DGL 0,2916
                db        00010000b        ;     db 00010000b
$DGL 0,2917
                db        00010001b        ;     db 00010001b
$DGL 0,2918
                db        00010010b        ;     db 00010010b
$DGL 0,2919
                db        00010011b        ;     db 00010011b
$DGL 0,2920
                db        00010100b        ;     db 00010100b
$DGL 0,2921
                db        00010101b        ;     db 00010101b
$DGL 0,2922
                db        00010110b        ;     db 00010110b
$DGL 0,2923
                db        00010111b        ;     db 00010111b
$DGL 0,2924
                db        00011000b        ;     db 00011000b
$DGL 0,2925
                db        00011001b        ;     db 00011001b
$DGL 0,2926
                db        00011010b        ;     db 00011010b
$DGL 0,2927
                db        00011011b        ;     db 00011011b
$DGL 0,2928
                db        00011100b        ;     db 00011100b
$DGL 0,2929
                db        00011101b        ;     db 00011101b
$DGL 0,2930
                db        00011110b        ;     db 00011110b
$DGL 0,2931
                db        00011111b        ;     db 00011111b
$DGL 0,2932
                db        00100000b        ;     db 00100000b
$DGL 0,2933
                db        00100001b        ;     db 00100001b
$DGL 0,2934
                db        00100010b        ;     db 00100010b
$DGL 0,2935
                db        00100011b        ;     db 00100011b
$DGL 0,2936
                db        00100100b        ;     db 00100100b
$DGL 0,2937
                db        00100101b        ;     db 00100101b
$DGL 0,2938
                db        00100110b        ;     db 00100110b
$DGL 0,2939
                db        00100111b        ;     db 00100111b
$DGL 0,2940
                db        00101000b        ;     db 00101000b
$DGL 0,2941
                db        00101001b        ;     db 00101001b
$DGL 0,2942
                db        00101010b        ;     db 00101010b
$DGL 0,2943
                db        00101011b        ;     db 00101011b
$DGL 0,2944
                db        00101100b        ;     db 00101100b
$DGL 0,2945
                db        00101101b        ;     db 00101101b
$DGL 0,2946
                db        00101110b        ;     db 00101110b
$DGL 0,2947
                db        00101111b        ;     db 00101111b
$DGL 0,2948
                db        00110000b        ;     db 00110000b
$DGL 0,2949
                db        00110001b        ;     db 00110001b
$DGL 0,2950
codebuffer_tab_end:                ;codebuffer_tab_end:
     
$DGL 0,2952
block_switch:                        ;block_switch:
$DGL 0,2953
                MOV        WDTE,#0ACH        ;      WDTE=#0ACH
$DGL 0,2954
                CMP        curdevstate,#1        ;      if(curdevstate==#1)
                BNZ        $?L339
$DGL 0,2955
                CMP        lastkeyidbak,#10        ;        if(lastkeyidbak<=#10)
                BZ        $$+4
                BNC        $?L340
$DGL 0,2956
                MOVW        ax,#DVD_BLOCK1        ;          ax=#DVD_BLOCK1
$DGL 0,2957
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,2958
                ret                ;          ret
$DGL 0,2959
?L340:                                ;        endif
$DGL 0,2960
                CMP        lastkeyidbak,#20        ;        if(lastkeyidbak<=#20)
                BZ        $$+4
                BNC        $?L341
$DGL 0,2961
                MOVW        ax,#DVD_BLOCK2        ;          ax=#DVD_BLOCK2
$DGL 0,2962
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,2963
                ret                ;          ret
$DGL 0,2964
?L341:                                ;        endif
$DGL 0,2965
                CMP        lastkeyidbak,#30        ;        if(lastkeyidbak<=#30)
                BZ        $$+4
                BNC        $?L342
$DGL 0,2966
                MOVW        ax,#DVD_BLOCK3        ;          ax=#DVD_BLOCK3
$DGL 0,2967
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,2968
                ret                ;          ret
$DGL 0,2969
?L342:                                ;        endif
$DGL 0,2970
                CMP        lastkeyidbak,#40        ;        if(lastkeyidbak<=#40)
                BZ        $$+4
                BNC        $?L343
$DGL 0,2971
                MOVW        ax,#DVD_BLOCK4        ;          ax=#DVD_BLOCK4
$DGL 0,2972
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,2973
                ret                ;          ret
$DGL 0,2974
?L343:                                ;        endif
$DGL 0,2975
                CMP        lastkeyidbak,#50        ;        if(lastkeyidbak<=#50)
                BZ        $$+4
                BNC        $?L344
$DGL 0,2976
                MOVW        ax,#DVD_BLOCK5        ;          ax=#DVD_BLOCK5
$DGL 0,2977
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,2978
                ret                ;          ret
$DGL 0,2979
?L344:                                ;        endif
$DGL 0,2980
?L339:                                ;      endif
$DGL 0,2981
                CMP        curdevstate,#2        ;      if(curdevstate==#2)
                BNZ        $?L345
$DGL 0,2982
                CMP        lastkeyidbak,#10        ;        if(lastkeyidbak<=#10)
                BZ        $$+4
                BNC        $?L346
$DGL 0,2983
                MOVW        ax,#STB_BLOCK1        ;          ax=#STB_BLOCK1
$DGL 0,2984
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,2985
                ret                ;          ret
$DGL 0,2986
?L346:                                ;        endif
$DGL 0,2987
                CMP        lastkeyidbak,#20        ;        if(lastkeyidbak<=#20)
                BZ        $$+4
                BNC        $?L347
$DGL 0,2988
                MOVW        ax,#STB_BLOCK2        ;          ax=#STB_BLOCK2
$DGL 0,2989
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,2990
                ret                ;          ret
$DGL 0,2991
?L347:                                ;        endif
$DGL 0,2992
                CMP        lastkeyidbak,#30        ;        if(lastkeyidbak<=#30)
                BZ        $$+4
                BNC        $?L348
$DGL 0,2993
                MOVW        ax,#STB_BLOCK3        ;          ax=#STB_BLOCK3
$DGL 0,2994
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,2995
                ret                ;          ret
$DGL 0,2996
?L348:                                ;        endif
$DGL 0,2997
                CMP        lastkeyidbak,#40        ;        if(lastkeyidbak<=#40)
                BZ        $$+4
                BNC        $?L349
$DGL 0,2998
                MOVW        ax,#STB_BLOCK4        ;          ax=#STB_BLOCK4
$DGL 0,2999
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,3000
                ret                ;          ret
$DGL 0,3001
?L349:                                ;        endif
$DGL 0,3002
                CMP        lastkeyidbak,#50        ;        if(lastkeyidbak<=#50)
                BZ        $$+4
                BNC        $?L350
$DGL 0,3003
                MOVW        ax,#STB_BLOCK4        ;          ax=#STB_BLOCK4
$DGL 0,3004
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,3005
                ret                ;          ret
$DGL 0,3006
?L350:                                ;        endif
$DGL 0,3007
?L345:                                ;      endif
$DGL 0,3008
                CMP        curdevstate,#3        ;      if(curdevstate==#3)
                BNZ        $?L351
$DGL 0,3009
                CMP        lastkeyidbak,#10        ;        if(lastkeyidbak<=#10)
                BZ        $$+4
                BNC        $?L352
$DGL 0,3010
                MOVW        ax,#AMP_BLOCK1        ;          ax=#AMP_BLOCK1
$DGL 0,3011
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,3012
                ret                ;          ret
$DGL 0,3013
?L352:                                ;        endif
$DGL 0,3014
                CMP        lastkeyidbak,#20        ;        if(lastkeyidbak<=#20)
                BZ        $$+4
                BNC        $?L353
$DGL 0,3015
                MOVW        ax,#AMP_BLOCK2        ;          ax=#AMP_BLOCK2
$DGL 0,3016
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,3017
                ret                ;          ret
$DGL 0,3018
?L353:                                ;        endif
$DGL 0,3019
                CMP        lastkeyidbak,#30        ;        if(lastkeyidbak<=#30)
                BZ        $$+4
                BNC        $?L354
$DGL 0,3020
                MOVW        ax,#AMP_BLOCK3        ;          ax=#AMP_BLOCK3
$DGL 0,3021
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,3022
                ret                ;          ret
$DGL 0,3023
?L354:                                ;        endif
$DGL 0,3024
                CMP        lastkeyidbak,#40        ;        if(lastkeyidbak<=#40)
                BZ        $$+4
                BNC        $?L355
$DGL 0,3025
                MOVW        ax,#AMP_BLOCK4        ;          ax=#AMP_BLOCK4
$DGL 0,3026
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,3027
                ret                ;          ret
$DGL 0,3028
?L355:                                ;        endif
$DGL 0,3029
                CMP        lastkeyidbak,#50        ;        if(lastkeyidbak<=#50)
                BZ        $$+4
                BNC        $?L356
$DGL 0,3030
                MOVW        ax,#AMP_BLOCK5        ;          ax=#AMP_BLOCK5
$DGL 0,3031
                MOVW        tEEPROM_BLOCK,ax        ;          tEEPROM_BLOCK=ax
$DGL 0,3032
                ret                ;          ret
$DGL 0,3033
?L356:                                ;        endif
$DGL 0,3034
?L351:                                ;      endif
$DGL 0,3035
ret                                ;ret

$DGL 0,3037
DVD_BLOCK1:                        ;DVD_BLOCK1:
$DGL 0,3038
                DB        00001111b        ;     DB 00001111b
$DGL 0,3039
DVD_BLOCK2:                        ;DVD_BLOCK2:
$DGL 0,3040
                DB        00010000b        ;     DB 00010000b
$DGL 0,3041
DVD_BLOCK3:                        ;DVD_BLOCK3:
$DGL 0,3042
                DB        00010001b        ;     DB 00010001b
$DGL 0,3043
DVD_BLOCK4:                        ;DVD_BLOCK4:
$DGL 0,3044
                DB        00010010b        ;     DB 00010010b
$DGL 0,3045
DVD_BLOCK5:                        ;DVD_BLOCK5:
$DGL 0,3046
                DB        00010011b        ;     DB 00010011b
$DGL 0,3047
STB_BLOCK1:                        ;STB_BLOCK1:
$DGL 0,3048
                DB        00010100b        ;     DB 00010100b
$DGL 0,3049
STB_BLOCK2:                        ;STB_BLOCK2:
$DGL 0,3050
                DB        00010101b        ;     DB 00010101b
$DGL 0,3051
STB_BLOCK3:                        ;STB_BLOCK3:
$DGL 0,3052
                DB        00010110b        ;     DB 00010110b
$DGL 0,3053
STB_BLOCK4:                        ;STB_BLOCK4:
$DGL 0,3054
                DB        00010111b        ;     DB 00010111b
$DGL 0,3055
STB_BLOCK5:                        ;STB_BLOCK5:
$DGL 0,3056
                DB        00011000b        ;     DB 00011000b
$DGL 0,3057
AMP_BLOCK1:                        ;AMP_BLOCK1:
$DGL 0,3058
                DB        00011001b        ;     DB 00011001b
$DGL 0,3059
AMP_BLOCK2:                        ;AMP_BLOCK2:
$DGL 0,3060
                DB        00011010b        ;     DB 00011010b
$DGL 0,3061
AMP_BLOCK3:                        ;AMP_BLOCK3:
$DGL 0,3062
                DB        00011011b        ;     DB 00011011b
$DGL 0,3063
AMP_BLOCK4:                        ;AMP_BLOCK4:
$DGL 0,3064
                DB        00011100b        ;     DB 00011100b
$DGL 0,3065
AMP_BLOCK5:                        ;AMP_BLOCK5:
$DGL 0,3066
                DB        00011101b        ;     DB 00011101b   

$DGL 0,3068
learn_pro:                        ;learn_pro:
$DGL 0,3069
                MOV        WDTE,#0ACH        ;   WDTE=#0ACH
$DGL 0,3070
                clr1        newkeypress        ;   clr1 newkeypress
$DGL 0,3071
                MOV        currentkeyid,#0        ;   currentkeyid=#0
$DGL 0,3072
                MOV        currentkeyidbak,#0        ;   currentkeyidbak=#0
$DGL 0,3073
                MOV        sendcodestate,#0        ;   sendcodestate=#0
$DGL 0,3074
                set1        nosendcode        ;   set1 nosendcode
$DGL 0,3075
                MOV        lastkeyid,#0        ;   lastkeyid=#0
$DGL 0,3076
                MOV        lastkeyidbak,#0        ;   lastkeyidbak=#0
$DGL 0,3077
                clr1        p1.7        ;   clr1 p1.7
     
$DGL 0,3079
                MOV        a,datanumber        ;   a=datanumber
$DGL 0,3080
                CMP        a,#10        ;   if(a<=#10)
                BZ        $$+4
                BNC        $?L357
$DGL 0,3081
                MOVW        temp,#0        ;     temp=#0
$DGL 0,3082
                br        !writeflash1        ;     br !writeflash1
$DGL 0,3083
?L357:                                ;   endif
$DGL 0,3084
                MOV        a,datanumber        ;   a=datanumber
$DGL 0,3085
                MOVW        temp,#0        ;   temp=#0
$DGL 0,3086
                MOV        tempdatanumber,a        ;   tempdatanumber=a
$DGL 0,3087
data_scale1:                        ;data_scale1:
$DGL 0,3088
                MOV        a,tempdatanumber        ;   a=tempdatanumber
$DGL 0,3089
                clr1        cy        ;   clr1 cy
$DGL 0,3090
                subc        a,#10        ;   subc a,#10
$DGL 0,3091
                MOV        tempdatanumber,a        ;   tempdatanumber=a
$DGL 0,3092
                MOV        a,temp        ;   a=temp
$DGL 0,3093
                INC        a        ;   a++
$DGL 0,3094
                MOV        temp,a        ;   temp=a
$DGL 0,3095
                MOV        a,tempdatanumber        ;   a=tempdatanumber
$DGL 0,3096
                cmp        a,#10        ;   cmp a,#10
$DGL 0,3097
                bz        $writeflash1        ;   bz $writeflash1
$DGL 0,3098
                bnc        $data_scale1        ;   bnc $data_scale1
   
$DGL 0,3100
writeflash1:                        ;writeflash1:
$DGL 0,3101
                MOV        a,temp        ;   a=temp
$DGL 0,3102
                MOV        x,#10        ;   x=#10
$DGL 0,3103
                mulu        x        ;   mulu x
$DGL 0,3104
                MOV        a,datanumber        ;   a=datanumber
$DGL 0,3105
                clr1        cy        ;   clr1 cy
$DGL 0,3106
                subc        a,x        ;   subc a,x
$DGL 0,3107
                MOV        keynumber,a        ;   keynumber=a
$DGL 0,3108
                DEC        a        ;   a--
$DGL 0,3109
                MOV        x,#100        ;   x=#100
$DGL 0,3110
                mulu        x        ;   mulu x
$DGL 0,3111
                MOVW        bc,ax        ;   bc=ax
   
$DGL 0,3113
                MOVW        ax,tEEPROM_BLOCK        ;   ax=tEEPROM_BLOCK
$DGL 0,3114
                MOVW        hl,ax        ;   hl=ax
$DGL 0,3115
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,3116
                call        !BlockToAddress        ;   call !BlockToAddress
$DGL 0,3117
                call        !twobytes_add        ;   call !twobytes_add
   
$DGL 0,3119
                MOVW        hl,ax        ;   hl=ax
$DGL 0,3120
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,3121
                CMP        a,#0FFH        ;   if(a==#0FFH)
                BNZ        $?L358
$DGL 0,3122
                clr1        tmif51        ;       clr1 tmif51
$DGL 0,3123
                set1        tmmk51        ;       set1 tmmk51
$DGL 0,3124
                clr1        tmif50        ;       clr1 tmif50
$DGL 0,3125
                set1        tmmk50        ;       set1 tmmk50
$DGL 0,3126
                clr1        toen1        ;       clr1 toen1
$DGL 0,3127
                clr1        tmhe1        ;       clr1 tmhe1
$DGL 0,3128
                clr1        tce51        ;       clr1 tce51
$DGL 0,3129
                clr1        p1.6        ;       clr1 p1.6
$DGL 0,3130
                set1        p1.7        ;       set1 p1.7
$DGL 0,3131
                clr1        learn_send        ;       clr1 learn_send
$DGL 0,3132
                clr1        key_press        ;       clr1 key_press
$DGL 0,3133
                clr1        newkeypress        ;       clr1 newkeypress
$DGL 0,3134
                ret                ;       ret
$DGL 0,3135
?L358:                                ;   endif
$DGL 0,3136
                MOV        datalength,a        ;     datalength=a
$DGL 0,3137
                MOV        b,a        ;     b=a
$DGL 0,3138
                MOV        a,[hl+b]        ;     a=[hl+b]
$DGL 0,3139
                CMP        a,#6        ;     if(a==#6)
                BNZ        $?L359
$DGL 0,3140
                set1        RC_6        ;       set1 RC_6
$DGL 0,3141
?L359:                                ;     endif
$DGL 0,3142
                CMP        a,#5        ;     if(a==#5)
                BNZ        $?L360
$DGL 0,3143
                set1        RC_5        ;       set1 RC_5
$DGL 0,3144
?L360:                                ;     endif
$DGL 0,3145
                CMP        a,#1        ;     if(a==#1)
                BNZ        $?L361
$DGL 0,3146
                set1        code429        ;       set1 code429
$DGL 0,3147
?L361:                                ;     endif
$DGL 0,3148
                CMP        a,#2        ;     if(a==#2)
                BNZ        $?L362
$DGL 0,3149
                set1        code345        ;       set1 code345
$DGL 0,3150
?L362:                                ;     endif
$DGL 0,3151
                BF        nofirsttime,$?L363        ;     if_bit(nofirsttime)
$DGL 0,3152
                MOV        a,l        ;       l+=#50,cy(a)
                ADDC        a,#50
                MOV        l,a
$DGL 0,3153
                MOV        a,h        ;       h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,3154
                MOV        a,[hl]        ;       a=[hl]
$DGL 0,3155
                MOV        datalength,a        ;       datalength=a
$DGL 0,3156
?L363:                                ;     endif
$DGL 0,3157
                MOVW        de,#EEPROMBuf        ;     de=#EEPROMBuf
$DGL 0,3158
                MOV        a,#0        ;     for(i=#0;i<datalength;i++)(a)
                MOV        i,a
?L364:
                MOV        a,i
                CMP        a,datalength
                BNC        $?L365
$DGL 0,3159
                MOV        a,[hl]        ;        a=[hl]
$DGL 0,3160
                MOV        [de],a        ;        [de]=a
$DGL 0,3161
                INCW        hl        ;        hl++
$DGL 0,3162
                INCW        de        ;        de++
                MOV        a,i
                INC        a
                MOV        i,a
                BR        ?L364
$DGL 0,3163
?L365:                                ;     next
$DGL 0,3164
                MOV        a,#0        ;     for(i=#0;i<=#7;i++)(a)
                MOV        i,a
?L366:
                MOV        a,i
                CMP        a,#7
                BZ        $$+4
                BNC        $?L367
$DGL 0,3165
                MOV        a,[hl]        ;        a=[hl]
$DGL 0,3166
                MOV        [de],a        ;        [de]=a
$DGL 0,3167
                INCW        hl        ;        hl++
$DGL 0,3168
                INCW        de        ;        de++
                MOV        a,i
                INC        a
                MOV        i,a
                BR        ?L366
$DGL 0,3169
?L367:                                ;     next

$DGL 0,3171
                call        !decompressdata        ;     call !decompressdata
$DGL 0,3172
                call        !learn_send_code        ;     call !learn_send_code
$DGL 0,3173
                BF        RC_6,$?L368        ;     if_bit(RC_6)
$DGL 0,3174
                BF        nofirsttime,$?L369        ;       if_bit(nofirsttime)
$DGL 0,3175
                clr1        nofirsttime        ;          clr1 nofirsttime
                BR        ?L370
$DGL 0,3176
?L369:                                ;       else
$DGL 0,3177
                set1        nofirsttime        ;          set1 nofirsttime
$DGL 0,3178
?L370:                                ;       endif
$DGL 0,3179
?L368:                                ;     endif
$DGL 0,3180
                BF        RC_5,$?L371        ;     if_bit(RC_5)
$DGL 0,3181
                BF        nofirsttime,$?L372        ;       if_bit(nofirsttime)
$DGL 0,3182
                clr1        nofirsttime        ;          clr1 nofirsttime
                BR        ?L373
$DGL 0,3183
?L372:                                ;       else
$DGL 0,3184
                set1        nofirsttime        ;          set1 nofirsttime
$DGL 0,3185
?L373:                                ;       endif
$DGL 0,3186
?L371:                                ;     endif
$DGL 0,3187
                BF        code429,$?L374        ;     if_bit(code429)
$DGL 0,3188
                BF        nofirsttime,$?L375        ;       if_bit(nofirsttime)
$DGL 0,3189
                clr1        nofirsttime        ;          clr1 nofirsttime
                BR        ?L376
$DGL 0,3190
?L375:                                ;       else
$DGL 0,3191
                set1        nofirsttime        ;          set1 nofirsttime
$DGL 0,3192
?L376:                                ;       endif
$DGL 0,3193
?L374:                                ;     endif
$DGL 0,3194
                BF        code345,$?L377        ;     if_bit(code345)
$DGL 0,3195
                BF        nofirsttime,$?L378        ;       if_bit(nofirsttime)
$DGL 0,3196
                clr1        nofirsttime        ;          clr1 nofirsttime
                BR        ?L379
$DGL 0,3197
?L378:                                ;       else
$DGL 0,3198
                set1        nofirsttime        ;          set1 nofirsttime
$DGL 0,3199
?L379:                                ;       endif
$DGL 0,3200
?L377:                                ;     endif
$DGL 0,3201
ret                                ;ret
$DGL 0,3202
learn_sub:                        ;learn_sub:
$DGL 0,3203
                MOV        WDTE,#0ACH        ;        WDTE=#0ACH
$DGL 0,3204
                clr1        p1.7        ;        clr1 p1.7
$DGL 0,3205
                MOV        sendcodestate,#0        ;        sendcodestate=#0
$DGL 0,3206
                set1        nosendcode        ;        set1 nosendcode
$DGL 0,3207
                MOV        delaycounter,#0001h        ;        delaycounter=#0001h
$DGL 0,3208
                MOV        counter,#0        ;        counter=#0                  
        
$DGL 0,3210
                MOV        PM0,#11111101B        ;        PM0=#11111101B
$DGL 0,3211
                MOV        P0,#00000000B        ;        P0=#00000000B
$DGL 0,3212
                MOV        ADPC,#00000100B        ;        ADPC=#00000100B
$DGL 0,3213
                MOV        PM2,#11110000B        ;        PM2=#11110000B
$DGL 0,3214
                MOV        P2,#00000000B        ;        P2=#00000000B
$DGL 0,3215
                MOV        PM1,#00000000B        ;        PM1=#00000000B
$DGL 0,3216
                MOV        P1,#00000000B        ;        P1=#00000000B
        
$DGL 0,3218
                MOV        PM3,#11111111B        ;        PM3=#11111111B
$DGL 0,3219
                MOV        P3,#00001111B        ;        P3=#00001111B
$DGL 0,3220
                MOV        PU3,#00001111B        ;        PU3=#00001111B
        
$DGL 0,3222
                MOV        PM6,#11111100B        ;        PM6=#11111100B
$DGL 0,3223
                MOV        P6,#00000000B        ;        P6=#00000000B
        
$DGL 0,3225
                MOV        PM12,#11111111B        ;        PM12=#11111111B
$DGL 0,3226
                MOV        P12,#00000001B        ;        P12=#00000001B
$DGL 0,3227
                MOV        PU12,#00000001B        ;        PU12=#00000001B
$DGL 0,3228
                clr1        pmk0        ;        clr1 pmk0
$DGL 0,3229
                clr1        pmk1        ;        clr1 pmk1
$DGL 0,3230
                clr1        pmk2        ;        clr1 pmk2
$DGL 0,3231
                clr1        pmk3        ;        clr1 pmk3
$DGL 0,3232
                clr1        pmk4        ;        clr1 pmk4              
$DGL 0,3233
                clr1        pif0        ;                          clr1 pif0
$DGL 0,3234
                clr1        pif1        ;                                 clr1 pif1
$DGL 0,3235
                clr1        pif2        ;                                 clr1 pif2
$DGL 0,3236
                clr1        pif3        ;                           clr1 pif3
$DGL 0,3237
                clr1        pif4        ;                           clr1 pif4        
$DGL 0,3238
                clr1        newkeypress        ;        clr1 newkeypress
$DGL 0,3239
                clr1        keypro_end        ;        clr1 keypro_end
$DGL 0,3240
                clr1        tmmk50        ;        clr1 tmmk50
$DGL 0,3241
                clr1        tmif50        ;        clr1 tmif50
$DGL 0,3242
                set1        tce50        ;        set1 tce50
$DGL 0,3243
delay3s:                        ;delay3s:
$DGL 0,3244
                MOV        WDTE,#0ACH        ;   WDTE=#0ACH
$DGL 0,3245
                nop                ;   nop
$DGL 0,3246
                nop                ;   nop
$DGL 0,3247
                halt                ;   halt
$DGL 0,3248
                nop                ;   nop
$DGL 0,3249
                nop                ;   nop
$DGL 0,3250
                BF        keyflag,$?L380        ;   if_bit(keyflag)
$DGL 0,3251
                clr1        keyflag        ;        clr1 keyflag
$DGL 0,3252
                set1        pmk0        ;        set1 pmk0
$DGL 0,3253
                set1        pmk1        ;        set1 pmk1
$DGL 0,3254
                set1        pmk2        ;        set1 pmk2
$DGL 0,3255
                set1        pmk3        ;        set1 pmk3
$DGL 0,3256
                set1        pmk4        ;        set1 pmk4
$DGL 0,3257
                clr1        pif0        ;              clr1 pif0
$DGL 0,3258
                clr1        pif1        ;              clr1 pif1
$DGL 0,3259
                clr1        pif2        ;              clr1 pif2
$DGL 0,3260
                clr1        pif3        ;               clr1 pif3
$DGL 0,3261
                clr1        pif4        ;               clr1 pif4
$DGL 0,3262
                clr1        lsrstop        ;               clr1 lsrstop
$DGL 0,3263
                MOV        keyscantime,#0        ;        keyscantime=#0
$DGL 0,3264
                MOV        currentkeyidbak,#0        ;               currentkeyidbak=#0                          
$DGL 0,3265
                call        !keyscansub        ;              call !keyscansub
$DGL 0,3266
                clr1        tmmk50        ;        clr1 tmmk50
$DGL 0,3267
                clr1        tmif50        ;              clr1 tmif50
$DGL 0,3268
                set1        tce50        ;        set1 tce50
$DGL 0,3269
?L380:                                ;   endif
$DGL 0,3270
                BF        timerflag,$?L381        ;    if_bit(timerflag)
$DGL 0,3271
                clr1        timerflag        ;      clr1 timerflag
$DGL 0,3272
                MOVW        ax,delaycounter        ;      if(delaycounter!=#0)(ax)
                CMPW        ax,#0
                BZ        $?L382
$DGL 0,3273
                MOVW        ax,delaycounter        ;              ax=delaycounter
$DGL 0,3274
                incw        ax        ;              incw ax
$DGL 0,3275
                MOVW        delaycounter,ax        ;              delaycounter=ax
$DGL 0,3276
                BF        learn_mode,$?L383        ;              if_bit(learn_mode)
$DGL 0,3277
                call        !keyscansub1        ;                 call !keyscansub1
$DGL 0,3278
?L383:                                ;              endif
                BR        ?L384
$DGL 0,3279
?L382:                                ;      else
$DGL 0,3280
                call        !keyscansub1        ;        call !keyscansub1
$DGL 0,3281
?L384:                                ;      endif
$DGL 0,3282
?L381:                                ;    endif
$DGL 0,3283
                MOVW        ax,delaycounter        ;   IF(delaycounter<#640)(ax)
                CMPW        ax,#640
                BC        $?L385
                BR        ?L386
?L385:
$DGL 0,3284
                MOV        WDTE,#0ACH        ;     WDTE=#0ACH
$DGL 0,3285
                call        !keyprocess        ;     call !keyprocess
$DGL 0,3286
                BF        switchkey,$?L387        ;     if_bit(switchkey)
$DGL 0,3287
                BT        nofirst_learn,$?L388        ;       if_bit(!nofirst_learn)      ;晭艐y檸箠幪彉槑螜F極,拵艗S晭皰S嫀簤幑寧?帋蕵?
$DGL 0,3288
                nop                ;          nop
                BR        ?L389
$DGL 0,3289
?L388:                                ;       else
$DGL 0,3290
                MOV        WDTE,#0ACH        ;          WDTE=#0ACH
$DGL 0,3291
                call        !init_mode        ;          call !init_mode          ;墡箷幣媦檸箠幪橣極,拵艗S弾藢T巜洕夿淪枎?
$DGL 0,3292
                ret                ;          ret
$DGL 0,3293
?L389:                                ;       endif
$DGL 0,3294
?L387:                                ;     endif
$DGL 0,3295
                BT        enable_learn,$?L390        ;     IF_BIT(enable_learn)          ;斿崨岴拵趲鷪幉榓 ,拵艗S3拫帋?弫曵 ,彉旈榓檸箤魦g?嫀覍\檸w擋孉戦媍?妅泿?
                BR        ?L391
?L390:
$DGL 0,3296
                set1        p1.7        ;       set1 p1.7
$DGL 0,3297
                set1        tmmk50        ;       set1 tmmk50
$DGL 0,3298
                clr1        tmif50        ;       clr1 tmif50
$DGL 0,3299
                clr1        tce50        ;       clr1 tce50
$DGL 0,3300
                MOV        WDTE,#0ACH        ;       WDTE=#0ACH
$DGL 0,3301
                clr1        enable_learn        ;       clr1 enable_learn           ;妿y橣極崫妅泿螘幆婸擮廁崕脵幑嫀駳y50,枡檸覊幑巵姈榰拵獢幫媍媷晭褣帯晭粯a媍孉戦帓泘橣媌媍戦泿硧c孉戦
$DGL 0,3302
                call        !delay500ms        ;       call !delay500ms
$DGL 0,3303
                MOV        WDTE,#0ACH        ;       WDTE=#0ACH
$DGL 0,3304
                call        !delay500ms        ;       call !delay500ms
$DGL 0,3305
                MOV        WDTE,#0ACH        ;       WDTE=#0ACH
$DGL 0,3306
                call        !portinit        ;       call !portinit
$DGL 0,3307
                call        !delay500ms        ;       call !delay500ms
$DGL 0,3308
                MOV        WDTE,#0ACH        ;       WDTE=#0ACH
$DGL 0,3309
                set1        p1.7        ;       set1 p1.7
$DGL 0,3310
                call        !delay500ms        ;       call !delay500ms
$DGL 0,3311
                MOV        WDTE,#0ACH        ;       WDTE=#0ACH
$DGL 0,3312
                clr1        p1.7        ;       clr1 p1.7                   ;彉槑?s湏歲媍檙晭?檸覊償幍攷蛵E拵趲鷻幭弾珗幉榓
$DGL 0,3313
                clr1        tmif50        ;       clr1 tmif50
$DGL 0,3314
                clr1        tmmk50        ;       clr1 tmmk50
$DGL 0,3315
                set1        tce50        ;       set1 tce50
$DGL 0,3316
                clr1        tmif010        ;       clr1 tmif010
$DGL 0,3317
                clr1        tmmk010        ;       clr1 tmmk010
$DGL 0,3318
                MOV        tmc00,#00001000b        ;       tmc00=#00001000b
$DGL 0,3319
                clr1        pm1.5        ;       clr1 pm1.5
$DGL 0,3320
                set1        p1.5        ;       set1 p1.5
$DGL 0,3321
                clr1        switchkey        ;       clr1 switchkey
$DGL 0,3322
                MOV        overflowtime,#0        ;       overflowtime=#0
$DGL 0,3323
                MOV        intervaloverflow1,#0        ;       intervaloverflow1=#0
$DGL 0,3324
                MOV        intervaloverflow2,#0        ;       intervaloverflow2=#0
$DGL 0,3325
                MOV        intervaloverflow3,#0        ;       intervaloverflow3=#0
$DGL 0,3326
                MOV        conscounter1,#0        ;       conscounter1=#0
$DGL 0,3327
                MOV        conscounter2,#0        ;       conscounter2=#0
$DGL 0,3328
                MOV        conscounter3,#0        ;       conscounter3=#0
$DGL 0,3329
                MOV        conscounter,#0        ;       conscounter=#0
$DGL 0,3330
                MOV        intervaltime,#0        ;       intervaltime=#0
$DGL 0,3331
                nop                ;       nop
$DGL 0,3332
                nop                ;       nop
$DGL 0,3333
                nop                ;       nop
$DGL 0,3334
                clr1        OVF00        ;       clr1 OVF00
$DGL 0,3335
                br        !delay10s        ;       br !delay10s
$DGL 0,3336
delay3ssub:                        ;delay3ssub:
$DGL 0,3337
                ret                ;       ret
$DGL 0,3338
?L391:                                ;     ENDIF
$DGL 0,3339
                br        !delay3s        ;     br !delay3s
                BR        ?L392
$DGL 0,3340
?L386:                                ;   ELSE
$DGL 0,3341
                call        !init_mode        ;     call !init_mode                       ;斿崨帋?晭瘞鈰\慾,拵艗S孴巜媆殠珢幉媍淪枎?
$DGL 0,3342
?L392:                                ;   ENDIF
$DGL 0,3343
ret                                ;ret

$DGL 0,3345
portinit:                        ;portinit:
$DGL 0,3346
                MOV        WDTE,#0ACH        ;        WDTE=#0ACH
$DGL 0,3347
                MOV        sendcodestate,#0        ;        sendcodestate=#0
$DGL 0,3348
                set1        nosendcode        ;        set1 nosendcode
$DGL 0,3349
                clr1        p1.7        ;        clr1 p1.7
$DGL 0,3350
                MOV        delaycounter,#0001h        ;        delaycounter=#0001h
$DGL 0,3351
                MOV        counter,#0        ;        counter=#0                   ;
        
$DGL 0,3353
                MOV        PM0,#11111101B        ;        PM0=#11111101B
$DGL 0,3354
                MOV        P0,#00000000B        ;        P0=#00000000B
$DGL 0,3355
                MOV        ADPC,#00000100B        ;        ADPC=#00000100B
$DGL 0,3356
                MOV        PM2,#11110000B        ;        PM2=#11110000B
$DGL 0,3357
                MOV        P2,#00000000B        ;        P2=#00000000B
$DGL 0,3358
                MOV        PM1,#00000000B        ;        PM1=#00000000B
$DGL 0,3359
                MOV        P1,#00000000B        ;        P1=#00000000B
        
$DGL 0,3361
                MOV        PM3,#11111111B        ;        PM3=#11111111B
$DGL 0,3362
                MOV        P3,#00001111B        ;        P3=#00001111B
$DGL 0,3363
                MOV        PU3,#00001111B        ;        PU3=#00001111B
      
$DGL 0,3365
                MOV        PM6,#11111100B        ;        PM6=#11111100B
$DGL 0,3366
                MOV        P6,#00000000B        ;        P6=#00000000B
        
$DGL 0,3368
                MOV        PM12,#11111111B        ;        PM12=#11111111B
$DGL 0,3369
                MOV        P12,#00000001B        ;        P12=#00000001B
$DGL 0,3370
                MOV        PU12,#00000001B        ;        PU12=#00000001B
$DGL 0,3371
                clr1        pmk0        ;        clr1 pmk0
$DGL 0,3372
                clr1        pmk1        ;        clr1 pmk1
$DGL 0,3373
                clr1        pmk2        ;        clr1 pmk2
$DGL 0,3374
                clr1        pmk3        ;        clr1 pmk3
$DGL 0,3375
                clr1        pmk4        ;        clr1 pmk4              
$DGL 0,3376
                clr1        pif0        ;                          clr1 pif0
$DGL 0,3377
                clr1        pif1        ;                                 clr1 pif1
$DGL 0,3378
                clr1        pif2        ;                                 clr1 pif2
$DGL 0,3379
                clr1        pif3        ;                           clr1 pif3
$DGL 0,3380
                clr1        pif4        ;                           clr1 pif4        
$DGL 0,3381
ret                                ;ret
$DGL 0,3382
init_mode:                        ;init_mode:
$DGL 0,3383
                MOV        WDTE,#0ACH        ;      WDTE=#0ACH                           ;
$DGL 0,3384
                set1        p1.7        ;      set1 p1.7
$DGL 0,3385
                clr1        p1.5        ;      clr1 p1.5
$DGL 0,3386
                clr1        tmif50        ;      clr1 tmif50
$DGL 0,3387
                set1        tmmk50        ;      set1 tmmk50
$DGL 0,3388
                clr1        tce50        ;      clr1 tce50
$DGL 0,3389
                clr1        tmifh0        ;      clr1 tmifh0
$DGL 0,3390
                set1        tmmkh0        ;      set1 tmmkh0
$DGL 0,3391
                clr1        tmhe0        ;      clr1 tmhe0                           
$DGL 0,3392
                clr1        tmif010        ;      clr1 tmif010
$DGL 0,3393
                set1        tmmk010        ;      set1 tmmk010
$DGL 0,3394
                MOV        tmc00,#00000000B        ;      tmc00=#00000000B
      
$DGL 0,3396
                MOV        currentkeyid,#0        ;      currentkeyid=#0
$DGL 0,3397
                MOV        currentkeyidbak,#0        ;      currentkeyidbak=#0
$DGL 0,3398
                MOV        sendcodestate,#0        ;      sendcodestate=#0
$DGL 0,3399
                MOV        lastkeyid,#0        ;      lastkeyid=#0
$DGL 0,3400
                MOV        lastkeyidbak,#0        ;      lastkeyidbak=#0
$DGL 0,3401
                MOVW        ax,#0        ;      delaycounter=#0(ax)
                MOVW        delaycounter,ax
$DGL 0,3402
                MOV        keyscantime,#0        ;      keyscantime=#0
$DGL 0,3403
                MOV        counter,#0        ;      counter=#0
$DGL 0,3404
                MOV        keypressedcounter,#0        ;      keypressedcounter=#0
$DGL 0,3405
                MOV        temporarycounter,#0        ;      temporarycounter=#0
$DGL 0,3406
                MOV        sendcodestate,#0        ;      sendcodestate=#0
$DGL 0,3407
                MOV        keynumber,#0        ;      keynumber=#0
$DGL 0,3408
                MOV        datanumber,#0        ;      datanumber=#0
$DGL 0,3409
                clr1        learn_mode        ;      clr1 learn_mode
$DGL 0,3410
                clr1        enable_learn        ;      clr1 enable_learn
$DGL 0,3411
                clr1        switchkey        ;      clr1 switchkey
$DGL 0,3412
                clr1        learn_send        ;      clr1 learn_send
$DGL 0,3413
                clr1        key_press        ;      clr1 key_press
$DGL 0,3414
                clr1        newkeypress        ;      clr1 newkeypress
$DGL 0,3415
                clr1        keypro_end        ;      clr1 keypro_end
$DGL 0,3416
                clr1        nosendcode        ;      clr1 nosendcode
$DGL 0,3417
                clr1        same1        ;      clr1 same1
$DGL 0,3418
                clr1        same2        ;      clr1 same2
$DGL 0,3419
                clr1        subflag        ;      clr1 subflag
$DGL 0,3420
                clr1        plusflag        ;      clr1 plusflag
$DGL 0,3421
                clr1        endcycle        ;      clr1 endcycle
$DGL 0,3422
                clr1        nofirst_learn        ;      clr1 nofirst_learn
$DGL 0,3423
                MOV        WDTE,#0ACH        ;      WDTE=#0ACH
$DGL 0,3424
                MOV        overflowtime,#0        ;      overflowtime=#0
$DGL 0,3425
                MOV        intervaloverflow1,#0        ;      intervaloverflow1=#0
$DGL 0,3426
                MOV        intervaloverflow2,#0        ;      intervaloverflow2=#0
$DGL 0,3427
                MOV        intervaloverflow3,#0        ;      intervaloverflow3=#0
$DGL 0,3428
                MOV        conscounter1,#0        ;      conscounter1=#0
$DGL 0,3429
                MOV        conscounter2,#0        ;      conscounter2=#0
$DGL 0,3430
                MOV        conscounter3,#0        ;      conscounter3=#0
$DGL 0,3431
                MOV        conscounter,#0        ;      conscounter=#0
$DGL 0,3432
                MOV        intervaltime,#0        ;      intervaltime=#0
$DGL 0,3433
ret                                ;ret
      
$DGL 0,3435
delay500ms:                        ;delay500ms:
$DGL 0,3436
                clr1        tmmkh0        ;      clr1 tmmkh0
$DGL 0,3437
                set1        tmhe0        ;      set1 tmhe0
$DGL 0,3438
                MOV        a,#01h        ;      h0counter=#01h(a)
                MOV        h0counter,a
$DGL 0,3439
delay500ms1:                        ;delay500ms1:
$DGL 0,3440
                MOV        WDTE,#0ACH        ;      WDTE=#0ACH
$DGL 0,3441
                nop                ;      nop
$DGL 0,3442
                nop                ;      nop
$DGL 0,3443
                halt                ;      halt
$DGL 0,3444
                nop                ;      nop
$DGL 0,3445
                nop                ;      nop
$DGL 0,3446
                MOV        a,h0counter        ;      if(h0counter<#250)(a)
                CMP        a,#250
                BNC        $?L393
$DGL 0,3447
                br        !delay500ms1        ;         br !delay500ms1
$DGL 0,3448
?L393:                                ;      endif                             
$DGL 0,3449
                MOV        a,#00h        ;      h0counter=#00h(a)                               
                MOV        h0counter,a
$DGL 0,3450
                clr1        tmifh0        ;      clr1 tmifh0
$DGL 0,3451
                set1        tmmkh0        ;      set1 tmmkh0
$DGL 0,3452
                clr1        tmhe0        ;      clr1 tmhe0
$DGL 0,3453
ret                                ;ret

$DGL 0,3455
delay10s:                        ;delay10s:
$DGL 0,3456
                MOV        WDTE,#0ACH        ;   WDTE=#0ACH
$DGL 0,3457
                nop                ;   nop
$DGL 0,3458
                nop                ;   nop
$DGL 0,3459
                halt                ;   halt
$DGL 0,3460
                nop                ;   nop
$DGL 0,3461
                nop                ;   nop
$DGL 0,3462
                MOVW        ax,delaycounter        ;   IF(delaycounter<#640)(ax)
                CMPW        ax,#640
                BC        $?L394
                BR        ?L395
?L394:
$DGL 0,3463
                MOV        WDTE,#0ACH        ;      WDTE=#0ACH
$DGL 0,3464
                BT        key_press,$?L396        ;      IF_BIT(key_press)
                BR        ?L397
?L396:
$DGL 0,3465
                set1        p1.7        ;          set1 p1.7
$DGL 0,3466
                clr1        tmif50        ;          clr1 tmif50
$DGL 0,3467
                set1        tmmk50        ;          set1 tmmk50
$DGL 0,3468
                clr1        tce50        ;          clr1 tce50
$DGL 0,3469
                MOV        a,counter        ;          a=counter
$DGL 0,3470
                DEC        a        ;          a--
$DGL 0,3471
                clr1        cy        ;          clr1 cy
$DGL 0,3472
                rol        a,1        ;          rol a,1
$DGL 0,3473
                and        a,#11111110b        ;          and a,#11111110b
$DGL 0,3474
                INC        a        ;          a++
$DGL 0,3475
                INC        a        ;          a++
$DGL 0,3476
                INC        a        ;          a++
$DGL 0,3477
                MOV        datalength,a        ;          datalength=a
$DGL 0,3478
                call        !compressdata1        ;          call !compressdata1
$DGL 0,3479
                call        !samestringsub        ;          call !samestringsub
$DGL 0,3480
                BT        samestring,$?L398        ;          IF_BIT(samestring)
                BR        ?L399
?L398:
$DGL 0,3481
                clr1        samestring        ;             clr1 samestring
$DGL 0,3482
                MOV        a,conscounter1        ;             counter=conscounter1(a)
                MOV        counter,a
$DGL 0,3483
                MOV        a,counter        ;             a=counter
$DGL 0,3484
                DEC        a        ;             a--
$DGL 0,3485
                clr1        cy        ;             clr1 cy
$DGL 0,3486
                rol        a,1        ;             rol a,1
$DGL 0,3487
                and        a,#11111110b        ;             and a,#11111110b
$DGL 0,3488
                INC        a        ;             a++
$DGL 0,3489
                INC        a        ;             a++
$DGL 0,3490
                INC        a        ;             a++
$DGL 0,3491
                MOV        datalength,a        ;             datalength=a
$DGL 0,3492
                MOVW        hl,#codeflowbyte        ;             hl=#codeflowbyte
$DGL 0,3493
                MOV        a,#0        ;             FOR(i=#0;i<#64;i++)(a)
                MOV        i,a
?L400:
                MOV        a,i
                CMP        a,#64
                BC        $?L401
                BR        ?L402
?L401:
$DGL 0,3494
                MOV        WDTE,#0ACH        ;               WDTE=#0ACH
$DGL 0,3495
                MOV        a,#0        ;               [hl]=#0(a)
                MOV        [hl],a
$DGL 0,3496
                INCW        hl        ;               hl++
                MOV        a,i
                INC        a
                MOV        i,a
                BR        ?L400
$DGL 0,3497
?L402:                                ;             NEXT
$DGL 0,3498
                MOVW        hl,#codetypedata        ;             hl=#codetypedata
$DGL 0,3499
                MOV        a,#0        ;             FOR(i=#0;i<#64;i++)(a)
                MOV        i,a
?L403:
                MOV        a,i
                CMP        a,#64
                BC        $?L404
                BR        ?L405
?L404:
$DGL 0,3500
                MOV        WDTE,#0ACH        ;               WDTE=#0ACH
$DGL 0,3501
                MOV        a,#0        ;               [hl]=#0(a)
                MOV        [hl],a
$DGL 0,3502
                INCW        hl        ;               hl++
                MOV        a,i
                INC        a
                MOV        i,a
                BR        ?L403
$DGL 0,3503
?L405:                                ;             NEXT
$DGL 0,3504
                MOVW        hl,#compressdatabyte        ;             hl=#compressdatabyte
$DGL 0,3505
                MOV        a,#0        ;             FOR(i=#0;i<#64;i++)(a)
                MOV        i,a
?L406:
                MOV        a,i
                CMP        a,#64
                BC        $?L407
                BR        ?L408
?L407:
$DGL 0,3506
                MOV        WDTE,#0ACH        ;               WDTE=#0ACH
$DGL 0,3507
                MOV        a,#0        ;               [hl]=#0(a)
                MOV        [hl],a
$DGL 0,3508
                INCW        hl        ;               hl++
                MOV        a,i
                INC        a
                MOV        i,a
                BR        ?L406
$DGL 0,3509
?L408:                                ;             NEXT
$DGL 0,3510
                MOVW        hl,#EEPROMBuf        ;             hl=#EEPROMBuf
$DGL 0,3511
                INCW        hl        ;             hl++
$DGL 0,3512
                INCW        hl        ;             hl++
$DGL 0,3513
                INCW        hl        ;             hl++
$DGL 0,3514
                MOV        a,counter        ;             a=counter
$DGL 0,3515
                DEC        a        ;             a--
$DGL 0,3516
                clr1        cy        ;             clr1 cy
$DGL 0,3517
                rol        a,1        ;             rol a,1
$DGL 0,3518
                and        a,#11111110b        ;             and a,#11111110b
$DGL 0,3519
                MOV        b,a        ;             b=a
$DGL 0,3520
                clr1        cy        ;             clr1 cy
$DGL 0,3521
                MOV        a,l        ;             l+=b,cy(a)
                ADDC        a,b
                MOV        l,a
$DGL 0,3522
                MOV        a,h        ;             h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,3523
                MOV        a,b        ;             FOR(i=b;i<#254;i++)(a)
                MOV        i,a
?L409:
                MOV        a,i
                CMP        a,#254
                BC        $?L410
                BR        ?L411
?L410:
$DGL 0,3524
                MOV        WDTE,#0ACH        ;                WDTE=#0ACH
$DGL 0,3525
                MOV        a,#0        ;               [hl]=#0(a)
                MOV        [hl],a
$DGL 0,3526
                INCW        hl        ;               hl++
                MOV        a,i
                INC        a
                MOV        i,a
                BR        ?L409
$DGL 0,3527
?L411:                                ;             NEXT
$DGL 0,3528
                MOV        a,#0        ;             [hl]=#0(a)
                MOV        [hl],a
$DGL 0,3529
                INCW        hl        ;             hl++
$DGL 0,3530
                MOV        a,#0        ;             [hl]=#0(a)
                MOV        [hl],a
$DGL 0,3531
                MOVW        hl,#EEPROMBuf        ;             hl=#EEPROMBuf
$DGL 0,3532
                INCW        hl        ;             hl++
$DGL 0,3533
                INCW        hl        ;             hl++
$DGL 0,3534
                INCW        hl        ;             hl++
$DGL 0,3535
                MOV        a,l        ;             l+=#255,cy(a)
                ADDC        a,#255
                MOV        l,a
$DGL 0,3536
                MOV        a,h        ;             h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,3537
                INCW        hl        ;             hl++
$DGL 0,3538
                MOV        a,#0        ;             FOR(i=#0;i<#152;i++)(a)
                MOV        i,a
?L412:
                MOV        a,i
                CMP        a,#152
                BC        $?L413
                BR        ?L414
?L413:
$DGL 0,3539
                MOV        WDTE,#0ACH        ;                WDTE=#0ACH
$DGL 0,3540
                MOV        a,#0        ;               [hl]=#0(a)
                MOV        [hl],a
$DGL 0,3541
                INCW        hl        ;               hl++
                MOV        a,i
                INC        a
                MOV        i,a
                BR        ?L412
$DGL 0,3542
?L414:                                ;             NEXT
$DGL 0,3543
                MOV        conscounter1,#0        ;             conscounter1=#0
$DGL 0,3544
                MOV        conscounter2,#0        ;             conscounter2=#0
$DGL 0,3545
                MOV        conscounter3,#0        ;             conscounter3=#0
$DGL 0,3546
                MOV        intervaloverflow1,#0        ;             intervaloverflow1=#0
$DGL 0,3547
                MOV        intervaloverflow2,#0        ;             intervaloverflow2=#0
$DGL 0,3548
                MOV        intervaloverflow3,#0        ;             intervaloverflow3=#0
$DGL 0,3549
                MOV        intervaltime,#0        ;             intervaltime=#0
$DGL 0,3550
                MOV        overflowtime,#0        ;             overflowtime=#0
$DGL 0,3551
                MOV        conscounter,#0        ;             conscounter=#0
$DGL 0,3552
                call        !compressdata1        ;             call !compressdata1
$DGL 0,3553
?L399:                                ;          ENDIF
$DGL 0,3554
                call        !flagdata_conv        ;          call !flagdata_conv
$DGL 0,3555
                call        !writelength_conv        ;          call !writelength_conv
$DGL 0,3556
                BF        RC_6,$?L415        ;          if_bit(RC_6)
$DGL 0,3557
                MOVW        hl,#codeflowbyte        ;             hl=#codeflowbyte
$DGL 0,3558
                MOV        a,#0        ;             FOR(i=#0;i<#64;i++)(a)
                MOV        i,a
?L416:
                MOV        a,i
                CMP        a,#64
                BC        $?L417
                BR        ?L418
?L417:
$DGL 0,3559
                MOV        WDTE,#0ACH        ;               WDTE=#0ACH
$DGL 0,3560
                MOV        a,#0        ;               [hl]=#0(a)
                MOV        [hl],a
$DGL 0,3561
                INCW        hl        ;               hl++
                MOV        a,i
                INC        a
                MOV        i,a
                BR        ?L416
$DGL 0,3562
?L418:                                ;             NEXT
$DGL 0,3563
                MOVW        hl,#codetypedata        ;             hl=#codetypedata
$DGL 0,3564
                MOV        a,#0        ;             FOR(i=#0;i<#64;i++)(a)
                MOV        i,a
?L419:
                MOV        a,i
                CMP        a,#64
                BC        $?L420
                BR        ?L421
?L420:
$DGL 0,3565
                MOV        WDTE,#0ACH        ;               WDTE=#0ACH
$DGL 0,3566
                MOV        a,#0        ;               [hl]=#0(a)
                MOV        [hl],a
$DGL 0,3567
                INCW        hl        ;               hl++
                MOV        a,i
                INC        a
                MOV        i,a
                BR        ?L419
$DGL 0,3568
?L421:                                ;             NEXT
$DGL 0,3569
                MOVW        hl,#compressdatabyte        ;             hl=#compressdatabyte
$DGL 0,3570
                MOV        a,#0        ;             FOR(i=#0;i<#64;i++)(a)
                MOV        i,a
?L422:
                MOV        a,i
                CMP        a,#64
                BC        $?L423
                BR        ?L424
?L423:
$DGL 0,3571
                MOV        WDTE,#0ACH        ;               WDTE=#0ACH
$DGL 0,3572
                MOV        a,#0        ;               [hl]=#0(a)
                MOV        [hl],a
$DGL 0,3573
                INCW        hl        ;               hl++
                MOV        a,i
                INC        a
                MOV        i,a
                BR        ?L422
$DGL 0,3574
?L424:                                ;             NEXT
$DGL 0,3575
                set1        nofirsttime        ;            set1 nofirsttime
$DGL 0,3576
                call        !deRC_6sub        ;            call !deRC_6sub
$DGL 0,3577
                call        !compressdata        ;            call !compressdata
$DGL 0,3578
                call        !flagdata_conv        ;            call !flagdata_conv
$DGL 0,3579
                MOV        conslength,#25        ;            conslength=#25
$DGL 0,3580
?L415:                                ;          endif
$DGL 0,3581
                BF        RC_5,$?L425        ;          if_bit(RC_5)
$DGL 0,3582
                set1        nofirsttime        ;            set1 nofirsttime
$DGL 0,3583
                call        !deRC_5sub        ;            call !deRC_5sub
$DGL 0,3584
                call        !compressdata        ;            call !compressdata
$DGL 0,3585
                call        !flagdata_conv        ;            call !flagdata_conv
$DGL 0,3586
                MOV        conslength,#25        ;            conslength=#25
$DGL 0,3587
?L425:                                ;          endif
$DGL 0,3588
                BF        code429,$?L426        ;          if_bit(code429)
$DGL 0,3589
                set1        nofirsttime        ;            set1 nofirsttime
$DGL 0,3590
                call        !desub429        ;            call !desub429
$DGL 0,3591
                call        !compressdata        ;            call !compressdata
$DGL 0,3592
                call        !flagdata_conv        ;            call !flagdata_conv
$DGL 0,3593
                MOV        conslength,#25        ;            conslength=#25
$DGL 0,3594
?L426:                                ;          endif
$DGL 0,3595
                BF        code345,$?L427        ;          if_bit(code345)
$DGL 0,3596
                set1        nofirsttime        ;            set1 nofirsttime
$DGL 0,3597
                call        !desub345        ;            call !desub345
$DGL 0,3598
                call        !compressdata        ;            call !compressdata
$DGL 0,3599
                call        !flagdata_conv        ;            call !flagdata_conv
$DGL 0,3600
                MOV        conslength,#25        ;            conslength=#25
$DGL 0,3601
?L427:                                ;          endif
$DGL 0,3602
                clr1        RC_6_pre        ;          clr1 RC_6_pre
$DGL 0,3603
                MOV        sametime,#0        ;          sametime=#0
$DGL 0,3604
                clr1        case1        ;          clr1 case1
$DGL 0,3605
                clr1        case2        ;          clr1 case2
$DGL 0,3606
                clr1        RC_6        ;          clr1 RC_6
$DGL 0,3607
                clr1        RC_5        ;          clr1 RC_5
$DGL 0,3608
                clr1        code429        ;          clr1 code429
$DGL 0,3609
                clr1        code345        ;          clr1 code345
$DGL 0,3610
                call        !selfprogrampro1        ;          call !selfprogrampro1
$DGL 0,3611
                call        !selfprogrampro2        ;          call !selfprogrampro2
$DGL 0,3612
                call        !selfprogrampro3        ;          call !selfprogrampro3
$DGL 0,3613
                clr1        key_press        ;          clr1 key_press
$DGL 0,3614
                MOV        WDTE,#0ACH        ;          WDTE=#0ACH                         ;彉槑?s湏歲媍檙晭?檸覊償幍攷蛵E拵趲鷻幭弾珗幉榓,攷蓹z峼夑媆媍媏昤朩檸箻a弾藲u慲慾
        
$DGL 0,3616
                call        !delay10ssub        ;          call !delay10ssub
          ;call !delay500ms
$DGL 0,3618
                call        !delay500ms        ;          call !delay500ms
$DGL 0,3619
                MOV        WDTE,#0ACH        ;          WDTE=#0ACH
$DGL 0,3620
                clr1        p1.7        ;          clr1 p1.7
$DGL 0,3621
                call        !delay500ms        ;          call !delay500ms
$DGL 0,3622
                MOV        WDTE,#0ACH        ;          WDTE=#0ACH
$DGL 0,3623
                set1        p1.7        ;          set1 p1.7
$DGL 0,3624
                call        !delay500ms        ;          call !delay500ms
$DGL 0,3625
                MOV        WDTE,#0ACH        ;          WDTE=#0ACH
$DGL 0,3626
                clr1        p1.5        ;          clr1 p1.5
$DGL 0,3627
                br        !learn_sub        ;          br !learn_sub
                BR        ?L428
$DGL 0,3628
?L397:                                ;      ELSE
$DGL 0,3629
                BF        keyflag,$?L429        ;         if_bit(keyflag)
$DGL 0,3630
                clr1        keyflag        ;               clr1 keyflag
$DGL 0,3631
                set1        pmk0        ;               set1 pmk0
$DGL 0,3632
                set1        pmk1        ;               set1 pmk1
$DGL 0,3633
                set1        pmk2        ;               set1 pmk2
$DGL 0,3634
                set1        pmk3        ;               set1 pmk3
$DGL 0,3635
                set1        pmk4        ;               set1 pmk4
$DGL 0,3636
                clr1        pif0        ;                     clr1 pif0
$DGL 0,3637
                clr1        pif1        ;                     clr1 pif1
$DGL 0,3638
                clr1        pif2        ;                     clr1 pif2
$DGL 0,3639
                clr1        pif3        ;                      clr1 pif3
$DGL 0,3640
                clr1        pif4        ;                      clr1 pif4
$DGL 0,3641
                clr1        lsrstop        ;                      clr1 lsrstop
$DGL 0,3642
                MOV        keyscantime,#0        ;               keyscantime=#0
$DGL 0,3643
                MOV        currentkeyidbak,#0        ;                      currentkeyidbak=#0                          
$DGL 0,3644
                call        !keyscansub        ;                     call !keyscansub
$DGL 0,3645
                clr1        tmmk50        ;               clr1 tmmk50
$DGL 0,3646
                clr1        tmif50        ;                     clr1 tmif50
$DGL 0,3647
                set1        tce50        ;               set1 tce50
$DGL 0,3648
?L429:                                ;         endif
$DGL 0,3649
                BF        timerflag,$?L430        ;    if_bit(timerflag)
$DGL 0,3650
                clr1        timerflag        ;      clr1 timerflag
$DGL 0,3651
                MOVW        ax,delaycounter        ;      if(delaycounter!=#0)(ax)
                CMPW        ax,#0
                BZ        $?L431
$DGL 0,3652
                MOVW        ax,delaycounter        ;              ax=delaycounter
$DGL 0,3653
                incw        ax        ;              incw ax
$DGL 0,3654
                MOVW        delaycounter,ax        ;              delaycounter=ax
$DGL 0,3655
                BF        learn_mode,$?L432        ;              if_bit(learn_mode)
$DGL 0,3656
                call        !keyscansub1        ;                 call !keyscansub1
$DGL 0,3657
?L432:                                ;              endif
                BR        ?L433
$DGL 0,3658
?L431:                                ;      else
$DGL 0,3659
                call        !keyscansub1        ;        call !keyscansub1
$DGL 0,3660
?L433:                                ;      endif
$DGL 0,3661
?L430:                                ;    endif  
$DGL 0,3662
                call        !keyprocess        ;         call !keyprocess
$DGL 0,3663
                MOV        WDTE,#0ACH        ;         WDTE=#0ACH
$DGL 0,3664
                BF        switchkey,$?L434        ;         if_bit(switchkey)                    ;攐嶼廁垘矘a孴巜殠珢幉媍淪枎?
$DGL 0,3665
                MOV        WDTE,#0ACH        ;              WDTE=#0ACH
$DGL 0,3666
                clr1        switchkey        ;              clr1 switchkey
$DGL 0,3667
                call        !init_mode        ;              call !init_mode
$DGL 0,3668
                br        !delay3ssub        ;              br !delay3ssub
$DGL 0,3669
?L434:                                ;         endif
$DGL 0,3670
                BF        enable_learn,$?L435        ;         if_bit(enable_learn)                 ;殠貗g?嫀覍\垘矌鷮A杔媍?妅泿?斿崨垘矘a慾塢檸w擋媍岴拵趲?拵艗S孴巜殠珢幉媍淪枎?
$DGL 0,3671
                MOV        WDTE,#0ACH        ;              WDTE=#0ACH
$DGL 0,3672
                clr1        enable_learn        ;              clr1 enable_learn
$DGL 0,3673
                call        !init_mode        ;              call !init_mode
$DGL 0,3674
                br        !delay3ssub        ;              br !delay3ssub
$DGL 0,3675
?L435:                                ;         endif        
$DGL 0,3676
?L428:                                ;      ENDIF
$DGL 0,3677
                br        !delay10s        ;        br !delay10s
                BR        ?L436
$DGL 0,3678
?L395:                                ;   ELSE                                   
$DGL 0,3679
                call        !init_mode        ;        call !init_mode                    ;斿崨帋?晭瘞鈰\慾 拵艗S孴巜殠珢幉媍淪枎?
$DGL 0,3680
?L436:                                ;   ENDIF
$DGL 0,3681
br                !delay3ssub        ;br !delay3ssub

$DGL 0,3683
delay10ssub:                        ;delay10ssub:
$DGL 0,3684
                BT        nofirst_learn,$?L437        ;   if_bit(!nofirst_learn)
$DGL 0,3685
                set1        nofirst_learn        ;             set1 nofirst_learn
$DGL 0,3686
?L437:                                ;   endif
$DGL 0,3687
ret                                ;ret
$DGL 0,3688
learn_send_code:                ;learn_send_code:
$DGL 0,3689
                MOV        a,conscounter1        ;  a=conscounter1
$DGL 0,3690
                clr1        cy        ;  clr1 cy
$DGL 0,3691
                ror        a,1        ;  ror a,1
$DGL 0,3692
                and        a,#01111111b        ;  and a,#01111111b
$DGL 0,3693
                MOV        conscounter1,a        ;  conscounter1=a
$DGL 0,3694
                MOV        a,conscounter2        ;  a=conscounter2
$DGL 0,3695
                clr1        cy        ;  clr1 cy
$DGL 0,3696
                ror        a,1        ;  ror a,1
$DGL 0,3697
                and        a,#01111111b        ;  and a,#01111111b
$DGL 0,3698
                MOV        conscounter2,a        ;  conscounter2=a
$DGL 0,3699
                MOV        a,conscounter3        ;  a=conscounter3
$DGL 0,3700
                clr1        cy        ;  clr1 cy
$DGL 0,3701
                ror        a,1        ;  ror a,1
$DGL 0,3702
                and        a,#01111111b        ;  and a,#01111111b
$DGL 0,3703
                MOV        conscounter3,a        ;  conscounter3=a
$DGL 0,3704
                clr1        p2.1        ;  clr1 p2.1
$DGL 0,3705
                clr1        lsrstop        ;  clr1 lsrstop
$DGL 0,3706
                clr1        p1.7        ;  clr1 p1.7
$DGL 0,3707
                set1        tmmk50        ;  set1 tmmk50
$DGL 0,3708
                set1        tmmk51        ;  set1 tmmk51
  
$DGL 0,3710
                clr1        pm1.6        ;  clr1 pm1.6
$DGL 0,3711
                clr1        p1.6        ;  clr1 p1.6
$DGL 0,3712
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,3713
                MOV        TMHMD1,#00000100B        ;  TMHMD1=#00000100B
$DGL 0,3714
                MOV        CMP01,#70        ;  CMP01=#70
$DGL 0,3715
                MOV        CMP11,#35        ;  CMP11=#35
$DGL 0,3716
                set1        tmcyc1.2        ;  set1 tmcyc1.2
$DGL 0,3717
                set1        tmcyc1.1        ;  set1 tmcyc1.1
  ;clr1 tmcyc1.1
   
$DGL 0,3720
                MOV        TCL51,#00000010B        ;  TCL51=#00000010B
$DGL 0,3721
                clr1        tmc51.1        ;  clr1 tmc51.1
$DGL 0,3722
                clr1        tmc51.6        ;  clr1 tmc51.6
$DGL 0,3723
                clr1        toe51        ;  clr1 toe51
$DGL 0,3724
                clr1        lvs51        ;  clr1 lvs51
$DGL 0,3725
                clr1        lvr51        ;  clr1 lvr51
$DGL 0,3726
                set1        tmhe1        ;  set1 tmhe1
$DGL 0,3727
                set1        tce51        ;  set1 tce51
  
$DGL 0,3729
                MOV        CR51,#255        ;  CR51=#255
$DGL 0,3730
                set1        tmcyc1.1        ;  set1 tmcyc1.1
$DGL 0,3731
?L438:                                ;  while_bit(!tmif51)      ;桮崫泜檸箟幓殠g淥旈寧輯嚀幓,妿蓵幆曗姈恲墵抁歰怚擈,帋诇O孉戦
                BT        tmif51,$?L439
$DGL 0,3732
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L438
$DGL 0,3733
?L439:                                ;  endw
$DGL 0,3734
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,3735
                set1        toen1        ;  set1 toen1              ;怚擈曗姈恲
  
$DGL 0,3737
                MOV        a,codelength        ;  a=codelength
$DGL 0,3738
                MOV        b,a        ;  b=a
$DGL 0,3739
                MOVW        de,#codeflowbyte        ;  de=#codeflowbyte
$DGL 0,3740
                MOV        i,#1        ;  i=#1
  
$DGL 0,3742
sendcode_sub:                        ;sendcode_sub:
$DGL 0,3743
                MOVW        hl,#codetypedata        ;  hl=#codetypedata
$DGL 0,3744
                MOV        a,[de]        ;  a=[de]
$DGL 0,3745
                clr1        cy        ;  clr1 cy
$DGL 0,3746
                rol        a,1        ;  rol a,1
$DGL 0,3747
                and        a,#11111110b        ;  and a,#11111110b
$DGL 0,3748
                clr1        cy        ;  clr1 cy
$DGL 0,3749
                rol        a,1        ;  rol a,1
$DGL 0,3750
                and        a,#11111100b        ;  and a,#11111100b
$DGL 0,3751
                clr1        cy        ;  clr1 cy
$DGL 0,3752
                ADDC        l,a        ;  l+=a,cy
$DGL 0,3753
                MOV        a,h        ;  h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
  
$DGL 0,3755
                call        !sub_send        ;  call !sub_send
$DGL 0,3756
                INC        i        ;  i++
$DGL 0,3757
                INCW        de        ;  de++

$DGL 0,3759
                dbnz        b,$sendcode_sub        ;  dbnz b,$sendcode_sub
  
$DGL 0,3761
                MOV        a,endcode        ;  a=endcode
$DGL 0,3762
                MOV        CR51,a        ;  CR51=a
$DGL 0,3763
                MOV1        cy,tmcyc1.1        ;  cy=tmcyc1.1
$DGL 0,3764
                MOV1        tmcyc1.1,cy        ;  tmcyc1.1=cy
$DGL 0,3765
?L440:                                ;  while_bit(!tmif51)
                BT        tmif51,$?L441
$DGL 0,3766
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L440
$DGL 0,3767
?L441:                                ;  endw
$DGL 0,3768
                clr1        tmif51        ;  clr1 tmif51
  
$DGL 0,3770
                MOV        a,endcode+1        ;  a=endcode+1
$DGL 0,3771
                MOV        c,a        ;  c=a
$DGL 0,3772
sendcode_sub3:                        ;sendcode_sub3:
$DGL 0,3773
                MOV        cr51,#0ffh        ;  cr51=#0ffh
$DGL 0,3774
                MOV1        cy,tmcyc1.1        ;  cy=tmcyc1.1
$DGL 0,3775
                MOV1        tmcyc1.1,cy        ;  tmcyc1.1=cy
$DGL 0,3776
                MOV        a,c        ;  if(c==#1)(a)
                CMP        a,#1
                BNZ        $?L442
$DGL 0,3777
                MOV1        cy,tmcyc1.1        ;    cy=tmcyc1.1
$DGL 0,3778
                not1        cy        ;    not1 cy
$DGL 0,3779
                MOV1        tmcyc1.1,cy        ;    tmcyc1.1=cy
$DGL 0,3780
?L442:                                ;  endif
$DGL 0,3781
?L443:                                ;  while_bit(!tmif51)
                BT        tmif51,$?L444
$DGL 0,3782
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L443
$DGL 0,3783
?L444:                                ;  endw
$DGL 0,3784
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,3785
                dbnz        c,$sendcode_sub3        ;  dbnz c,$sendcode_sub3
   
$DGL 0,3787
                clr1        toen1        ;    clr1 toen1
$DGL 0,3788
                set1        pm1.6        ;    set1 pm1.6
$DGL 0,3789
                clr1        p1.6        ;    clr1 p1.6
$DGL 0,3790
                clr1        tmif51        ;    clr1 tmif51
$DGL 0,3791
                set1        tmmk51        ;    set1 tmmk51
$DGL 0,3792
                clr1        tmif50        ;    clr1 tmif50
$DGL 0,3793
                clr1        tmmk50        ;    clr1 tmmk50
$DGL 0,3794
                clr1        tmhe1        ;    clr1 tmhe1
$DGL 0,3795
                clr1        tce51        ;    clr1 tce51
$DGL 0,3796
                set1        p1.7        ;    set1 p1.7
$DGL 0,3797
                clr1        key_press        ;    clr1 key_press
$DGL 0,3798
                clr1        learn_send        ;    clr1 learn_send
$DGL 0,3799
                clr1        OVF00        ;    clr1 OVF00
$DGL 0,3800
                MOV        intervaloverflow1,#0        ;    intervaloverflow1=#0
$DGL 0,3801
                MOV        intervaloverflow2,#0        ;    intervaloverflow2=#0
$DGL 0,3802
                MOV        intervaloverflow3,#0        ;    intervaloverflow3=#0
$DGL 0,3803
                MOV        conscounter1,#0        ;    conscounter1=#0
$DGL 0,3804
                MOV        conscounter2,#0        ;    conscounter2=#0
$DGL 0,3805
                MOV        conscounter3,#0        ;    conscounter3=#0
$DGL 0,3806
                MOV        overflowtime,#0        ;    overflowtime=#0
$DGL 0,3807
                MOV        conscounter,#0        ;    conscounter=#0
$DGL 0,3808
                MOV        intervaltime,#0        ;    intervaltime=#0
$DGL 0,3809
ret                                ;ret
$DGL 0,3810
sub_send:                        ;sub_send:
$DGL 0,3811
                MOV        a,[hl]        ;  a=[hl]
$DGL 0,3812
                CMP        a,#0        ;  if(a!=#0)  
                BZ        $?L445
$DGL 0,3813
                MOV        CR51,a        ;    CR51=a
$DGL 0,3814
                MOV1        cy,tmcyc1.1        ;    cy=tmcyc1.1
$DGL 0,3815
                MOV1        tmcyc1.1,cy        ;    tmcyc1.1=cy
$DGL 0,3816
?L446:                                ;    while_bit(!tmif51)
                BT        tmif51,$?L447
$DGL 0,3817
                MOV        WDTE,#0ACH        ;      WDTE=#0ACH
                BR        ?L446
$DGL 0,3818
?L447:                                ;    endw
$DGL 0,3819
                clr1        tmif51        ;    clr1 tmif51
$DGL 0,3820
?L445:                                ;  endif
  
$DGL 0,3822
                INCW        hl        ;  hl++
$DGL 0,3823
                MOV        a,[hl]        ;  a=[hl]
$DGL 0,3824
                CMP        a,#0        ;  if(a!=#0)
                BZ        $?L448
$DGL 0,3825
                MOV        c,a        ;    c=a
$DGL 0,3826
sendcode_sub1:                        ;sendcode_sub1:  
$DGL 0,3827
                MOV        CR51,#0FFH        ;    CR51=#0FFH
$DGL 0,3828
                MOV1        cy,tmcyc1.1        ;    cy=tmcyc1.1
$DGL 0,3829
                MOV1        tmcyc1.1,cy        ;    tmcyc1.1=cy
  
$DGL 0,3831
                MOV        a,c        ;    if(c==#1)(a)
                CMP        a,#1
                BNZ        $?L449
$DGL 0,3832
                MOV1        cy,tmcyc1.1        ;      cy=tmcyc1.1
$DGL 0,3833
                not1        cy        ;      not1 cy
$DGL 0,3834
                MOV1        tmcyc1.1,cy        ;      tmcyc1.1=cy
$DGL 0,3835
?L449:                                ;    endif
$DGL 0,3836
?L450:                                ;    while_bit(!tmif51)
                BT        tmif51,$?L451
$DGL 0,3837
                MOV        WDTE,#0ACH        ;      WDTE=#0ACH
                BR        ?L450
$DGL 0,3838
?L451:                                ;    endw
$DGL 0,3839
                clr1        tmif51        ;    clr1 tmif51
$DGL 0,3840
                dbnz        c,$sendcode_sub1        ;    dbnz c,$sendcode_sub1
$DGL 0,3841
?L448:                                ;  endif
  
$DGL 0,3843
                CMP        intervaloverflow1,#0        ;  if(intervaloverflow1!=#0)
                BZ        $?L452
$DGL 0,3844
                call        !overflow_pro        ;     call !overflow_pro
$DGL 0,3845
?L452:                                ;  endif
  
$DGL 0,3847
                INCW        hl        ;  hl++
$DGL 0,3848
                MOV        a,[hl]        ;  a=[hl]
$DGL 0,3849
                CMP        a,#0        ;  if(a!=#0)
                BZ        $?L453
$DGL 0,3850
                MOV        CR51,a        ;  CR51=a
$DGL 0,3851
                MOV1        cy,tmcyc1.1        ;  cy=tmcyc1.1
$DGL 0,3852
                MOV1        tmcyc1.1,cy        ;  tmcyc1.1=cy
$DGL 0,3853
?L454:                                ;  while_bit(!tmif51)
                BT        tmif51,$?L455
$DGL 0,3854
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L454
$DGL 0,3855
?L455:                                ;  endw
$DGL 0,3856
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,3857
?L453:                                ;  endif
  
$DGL 0,3859
                INCW        hl        ;  hl++
$DGL 0,3860
                MOV        a,[hl]        ;  a=[hl]
$DGL 0,3861
                CMP        a,#0        ;  if(a!=#0)
                BZ        $?L456
$DGL 0,3862
                MOV        c,a        ;  c=a  
$DGL 0,3863
sendcode_sub2:                        ;sendcode_sub2:  
$DGL 0,3864
                MOV        CR51,#0FFH        ;  CR51=#0FFH
$DGL 0,3865
                MOV1        cy,tmcyc1.1        ;  cy=tmcyc1.1
$DGL 0,3866
                MOV1        tmcyc1.1,cy        ;  tmcyc1.1=cy
$DGL 0,3867
                MOV        a,c        ;  if(c==#1)(a)
                CMP        a,#1
                BNZ        $?L457
$DGL 0,3868
                MOV1        cy,tmcyc1.1        ;    cy=tmcyc1.1
$DGL 0,3869
                not1        cy        ;    not1 cy
$DGL 0,3870
                MOV1        tmcyc1.1,cy        ;    tmcyc1.1=cy
$DGL 0,3871
?L457:                                ;  endif
$DGL 0,3872
?L458:                                ;  while_bit(!tmif51)
                BT        tmif51,$?L459
$DGL 0,3873
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L458
$DGL 0,3874
?L459:                                ;  endw
  
$DGL 0,3876
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,3877
                dbnz        c,$sendcode_sub2        ;  dbnz c,$sendcode_sub2
$DGL 0,3878
?L456:                                ;  endif
$DGL 0,3879
ret                                ;ret

$DGL 0,3881
overflow_pro:                        ;overflow_pro:
$DGL 0,3882
                MOV        a,i        ;  if(i==conscounter1)(a)
                CMP        a,conscounter1
                BNZ        $?L460
$DGL 0,3883
                push        bc        ;  push bc
$DGL 0,3884
                MOV        a,intervaloverflow1        ;  b=intervaloverflow1(a)
                MOV        b,a
$DGL 0,3885
overflow_pro11:                        ;overflow_pro11:
$DGL 0,3886
                MOV        c,#0ffh        ;  c=#0ffh
$DGL 0,3887
overflow_pro1:                        ;overflow_pro1:
$DGL 0,3888
                MOV        CR51,#0FFH        ;  CR51=#0FFH
$DGL 0,3889
                MOV1        cy,tmcyc1.1        ;  cy=tmcyc1.1
$DGL 0,3890
                MOV1        tmcyc1.1,cy        ;  tmcyc1.1=cy
$DGL 0,3891
?L461:                                ;  while_bit(!tmif51)
                BT        tmif51,$?L462
$DGL 0,3892
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L461
$DGL 0,3893
?L462:                                ;  endw
  
$DGL 0,3895
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,3896
                dbnz        c,$overflow_pro1        ;  dbnz c,$overflow_pro1
$DGL 0,3897
                MOV        CR51,#0FFH        ;  CR51=#0FFH
$DGL 0,3898
                MOV1        cy,tmcyc1.1        ;  cy=tmcyc1.1
$DGL 0,3899
                MOV1        tmcyc1.1,cy        ;  tmcyc1.1=cy
$DGL 0,3900
?L463:                                ;  while_bit(!tmif51)
                BT        tmif51,$?L464
$DGL 0,3901
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L463
$DGL 0,3902
?L464:                                ;  endw
  
$DGL 0,3904
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,3905
                dbnz        b,$overflow_pro11        ;  dbnz b,$overflow_pro11
$DGL 0,3906
                pop        bc        ;  pop bc
$DGL 0,3907
?L460:                                ;  endif
$DGL 0,3908
                MOV        a,i        ;  if(i==conscounter2)(a)
                CMP        a,conscounter2
                BNZ        $?L465
$DGL 0,3909
                push        bc        ;  push bc
$DGL 0,3910
                MOV        a,intervaloverflow2        ;  if(intervaloverflow2!=#0)(a)
                CMP        a,#0
                BZ        $?L466
$DGL 0,3911
                MOV        a,intervaloverflow2        ;  b=intervaloverflow2(a)
                MOV        b,a
$DGL 0,3912
overflow_pro22:                        ;overflow_pro22:
$DGL 0,3913
                MOV        c,#0ffh        ;  c=#0ffh
$DGL 0,3914
overflow_pro2:                        ;overflow_pro2:
$DGL 0,3915
                MOV        CR51,#0FFH        ;  CR51=#0FFH
$DGL 0,3916
                MOV1        cy,tmcyc1.1        ;  cy=tmcyc1.1
$DGL 0,3917
                MOV1        tmcyc1.1,cy        ;  tmcyc1.1=cy
$DGL 0,3918
?L467:                                ;  while_bit(!tmif51)
                BT        tmif51,$?L468
$DGL 0,3919
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L467
$DGL 0,3920
?L468:                                ;  endw
  
$DGL 0,3922
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,3923
                dbnz        c,$overflow_pro2        ;  dbnz c,$overflow_pro2
$DGL 0,3924
                MOV        CR51,#0FFH        ;  CR51=#0FFH
$DGL 0,3925
                MOV1        cy,tmcyc1.1        ;  cy=tmcyc1.1
$DGL 0,3926
                MOV1        tmcyc1.1,cy        ;  tmcyc1.1=cy
$DGL 0,3927
?L469:                                ;  while_bit(!tmif51)
                BT        tmif51,$?L470
$DGL 0,3928
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L469
$DGL 0,3929
?L470:                                ;  endw
  
$DGL 0,3931
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,3932
                dbnz        b,$overflow_pro22        ;  dbnz b,$overflow_pro22
$DGL 0,3933
?L466:                                ;  endif
$DGL 0,3934
                pop        bc        ;  pop bc
$DGL 0,3935
?L465:                                ;  endif
  
$DGL 0,3937
                MOV        a,i        ;  if(i==conscounter3)(a)
                CMP        a,conscounter3
                BNZ        $?L471
$DGL 0,3938
                push        bc        ;  push bc
$DGL 0,3939
                MOV        a,intervaloverflow3        ;  if(intervaloverflow3!=#0)(a)
                CMP        a,#0
                BZ        $?L472
$DGL 0,3940
                MOV        a,intervaloverflow3        ;  b=intervaloverflow3(a)
                MOV        b,a
$DGL 0,3941
overflow_pro33:                        ;overflow_pro33:
$DGL 0,3942
                MOV        c,#0ffh        ;  c=#0ffh
$DGL 0,3943
overflow_pro3:                        ;overflow_pro3:
$DGL 0,3944
                MOV        CR51,#0FFH        ;  CR51=#0FFH
$DGL 0,3945
                MOV1        cy,tmcyc1.1        ;  cy=tmcyc1.1
$DGL 0,3946
                MOV1        tmcyc1.1,cy        ;  tmcyc1.1=cy
$DGL 0,3947
?L473:                                ;  while_bit(!tmif51)
                BT        tmif51,$?L474
$DGL 0,3948
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L473
$DGL 0,3949
?L474:                                ;  endw
  
$DGL 0,3951
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,3952
                dbnz        c,$overflow_pro3        ;  dbnz c,$overflow_pro3
$DGL 0,3953
                MOV        CR51,#0FFH        ;  CR51=#0FFH
$DGL 0,3954
                MOV1        cy,tmcyc1.1        ;  cy=tmcyc1.1
$DGL 0,3955
                MOV1        tmcyc1.1,cy        ;  tmcyc1.1=cy
$DGL 0,3956
?L475:                                ;  while_bit(!tmif51)
                BT        tmif51,$?L476
$DGL 0,3957
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L475
$DGL 0,3958
?L476:                                ;  endw
  
$DGL 0,3960
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,3961
                dbnz        b,$overflow_pro33        ;  dbnz b,$overflow_pro33
$DGL 0,3962
?L472:                                ;  endif
$DGL 0,3963
                pop        bc        ;  pop bc
$DGL 0,3964
?L471:                                ;  endif
$DGL 0,3965
                ret                ;  ret

$DGL 0,3967
sendcode:                        ;sendcode:
$DGL 0,3968
                BF        learn_mode,$?L477        ;if_bit(learn_mode)
$DGL 0,3969
                ret                ;  ret
$DGL 0,3970
?L477:                                ;endif
$DGL 0,3971
                BF        learn_send,$?L478        ;if_bit(learn_send)
$DGL 0,3972
                ret                ;  ret
$DGL 0,3973
?L478:                                ;endif
$DGL 0,3974
                BT        keypro_end,$?L479        ;if_bit(!keypro_end)
$DGL 0,3975
                ret                ;     ret
$DGL 0,3976
?L479:                                ;endif
$DGL 0,3977
                CMP        sendcodestate,#0        ;if(sendcodestate==#0)
                BNZ        $?L480
$DGL 0,3978
                ret                ;                  ret
$DGL 0,3979
?L480:                                ;endif
$DGL 0,3980
clr1                keypro_end        ;clr1 keypro_end
$DGL 0,3981
                CMP        sendcodestate,#1        ;if(sendcodestate==#1)
                BNZ        $?L481
$DGL 0,3982
                MOV        sendcodestate,#0        ;    sendcodestate=#0   
$DGL 0,3983
                BT        nosendcode,$?L482        ;    if_bit(!nosendcode)
$DGL 0,3984
                call        !sendcode1        ;        call !sendcode1
$DGL 0,3985
?L482:                                ;    endif
$DGL 0,3986
?L481:                                ;endif
$DGL 0,3987
                CMP        sendcodestate,#2        ; if(sendcodestate==#2)
                BNZ        $?L483
$DGL 0,3988
                MOV        sendcodestate,#0        ;   sendcodestate=#0
$DGL 0,3989
                BT        nosendcode,$?L484        ;   if_bit(!nosendcode)
$DGL 0,3990
                set1        tmmk51        ;     set1 tmmk51
$DGL 0,3991
                clr1        p1.7        ;     clr1 p1.7
$DGL 0,3992
                set1        tmmk50        ;     set1 tmmk50
     ;clr1 tmmk50
         
$DGL 0,3995
                clr1        p1.6        ;     clr1 p1.6
$DGL 0,3996
                clr1        tmif51        ;     clr1 tmif51
$DGL 0,3997
                MOV        TMHMD1,#00000100B        ;     TMHMD1=#00000100B
     ;CMP01=#69
     ;CMP11=#34                  ;
$DGL 0,4000
                MOV        CMP01,#73        ;     CMP01=#73
$DGL 0,4001
                MOV        CMP11,#36        ;     CMP11=#36                   ;
$DGL 0,4002
                set1        tmcyc1.2        ;     set1 tmcyc1.2
     ;clr1 tmcyc1.2              ;
     
   
$DGL 0,4006
                MOV        TCL51,#00000110B        ;     TCL51=#00000110B
$DGL 0,4007
                clr1        tmc51.1        ;     clr1 tmc51.1
$DGL 0,4008
                clr1        tmc51.6        ;     clr1 tmc51.6
$DGL 0,4009
                clr1        toe51        ;     clr1 toe51
$DGL 0,4010
                clr1        lvs51        ;     clr1 lvs51
$DGL 0,4011
                clr1        lvr51        ;     clr1 lvr51
$DGL 0,4012
                set1        toen1        ;     set1 toen1
$DGL 0,4013
                set1        tmhe1        ;     set1 tmhe1
$DGL 0,4014
                set1        tce51        ;     set1 tce51

$DGL 0,4016
                MOV        CR51,#140        ;     CR51=#140
$DGL 0,4017
                clr1        tmcyc1.1        ;     clr1 tmcyc1.1
$DGL 0,4018
?L485:                                ;     while_bit(!tmif51)
                BT        tmif51,$?L486
$DGL 0,4019
                MOV        WDTE,#0ACH        ;        WDTE=#0ACH
                BR        ?L485
$DGL 0,4020
?L486:                                ;     endw
$DGL 0,4021
                clr1        tmif51        ;     clr1 tmif51
     
$DGL 0,4023
                MOV        CR51,#38        ;     CR51=#38
$DGL 0,4024
                set1        tmcyc1.1        ;     set1 tmcyc1.1
$DGL 0,4025
?L487:                                ;     while_bit(!tmif51)
                BT        tmif51,$?L488
$DGL 0,4026
                MOV        WDTE,#0ACH        ;        WDTE=#0ACH
                BR        ?L487
$DGL 0,4027
?L488:                                ;     endw
$DGL 0,4028
                clr1        tmif51        ;     clr1 tmif51
     
$DGL 0,4030
                MOV        CR51,#8        ;     CR51=#8
$DGL 0,4031
                set1        tmcyc1.1        ;     set1 tmcyc1.1
$DGL 0,4032
?L489:                                ;     while_bit(!tmif51)
                BT        tmif51,$?L490
$DGL 0,4033
                MOV        WDTE,#0ACH        ;        WDTE=#0ACH
                BR        ?L489
$DGL 0,4034
?L490:                                ;     endw
$DGL 0,4035
                clr1        tmif51        ;     clr1 tmif51
$DGL 0,4036
?L484:                                ;   endif
$DGL 0,4037
?L483:                                ; endif
$DGL 0,4038
                clr1        nosendcode        ;    clr1 nosendcode
$DGL 0,4039
                set1        tmmk51        ;    set1 tmmk51
$DGL 0,4040
                clr1        tce51        ;    clr1 tce51
   
$DGL 0,4042
                clr1        tmif50        ;    clr1 tmif50
$DGL 0,4043
                clr1        tmmk50        ;    clr1 tmmk50
   
$DGL 0,4045
                clr1        toen1        ;    clr1 toen1
$DGL 0,4046
                clr1        tmhe1        ;    clr1 tmhe1
   
$DGL 0,4048
                clr1        p1.6        ;    clr1 p1.6
$DGL 0,4049
                set1        p1.7        ;    set1 p1.7
$DGL 0,4050
ret                                ;ret

$DGL 0,4052
sendcode1:                        ;sendcode1:
$DGL 0,4053
                clr1        p1.7        ;  clr1 p1.7
$DGL 0,4054
                set1        tmmk50        ;  set1 tmmk50
  ;clr1 tmmk50
$DGL 0,4056
                set1        tmmk51        ;  set1 tmmk51
  
$DGL 0,4058
                clr1        p1.6        ;  clr1 p1.6
$DGL 0,4059
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,4060
                MOV        TMHMD1,#00000100B        ;  TMHMD1=#00000100B
  ;CMP01=#69
  ;CMP11=#34                       ;
$DGL 0,4063
                MOV        CMP01,#73        ;  CMP01=#73
$DGL 0,4064
                MOV        CMP11,#36        ;  CMP11=#36                        ;
$DGL 0,4065
                set1        tmcyc1.2        ;  set1 tmcyc1.2
  ;clr1 tmcyc1.2                   ;
$DGL 0,4067
                set1        tmcyc1.1        ;  set1 tmcyc1.1
   
$DGL 0,4069
                MOV        TCL51,#00000110B        ;  TCL51=#00000110B
$DGL 0,4070
                clr1        tmc51.1        ;  clr1 tmc51.1
$DGL 0,4071
                clr1        tmc51.6        ;  clr1 tmc51.6
$DGL 0,4072
                clr1        toe51        ;  clr1 toe51
$DGL 0,4073
                clr1        lvs51        ;  clr1 lvs51
$DGL 0,4074
                clr1        lvr51        ;  clr1 lvr51
  ;set1 toen1
$DGL 0,4076
                set1        tmhe1        ;  set1 tmhe1
$DGL 0,4077
                set1        tce51        ;  set1 tce51

$DGL 0,4079
                MOV        CR51,#69        ;  CR51=#69
$DGL 0,4080
                set1        tmcyc1.1        ;  set1 tmcyc1.1
$DGL 0,4081
?L491:                                ;  while_bit(!tmif51)    ;4.48ms
                BT        tmif51,$?L492
$DGL 0,4082
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L491
$DGL 0,4083
?L492:                                ;  endw
$DGL 0,4084
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,4085
                set1        toen1        ;  set1 toen1              ;
  
$DGL 0,4087
                MOV        CR51,#69        ;  CR51=#69
$DGL 0,4088
                set1        tmcyc1.1        ;  set1 tmcyc1.1
$DGL 0,4089
?L493:                                ;  while_bit(!tmif51)     ;4.48ms
                BT        tmif51,$?L494
$DGL 0,4090
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L493
$DGL 0,4091
?L494:                                ;  endw
$DGL 0,4092
                clr1        tmif51        ;  clr1 tmif51
  
$DGL 0,4094
                MOV        CR51,#69        ;  CR51=#69
$DGL 0,4095
                clr1        tmcyc1.1        ;  clr1 tmcyc1.1
$DGL 0,4096
?L495:                                ;  while_bit(!tmif51)     ;4.48ms
                BT        tmif51,$?L496
$DGL 0,4097
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L495
$DGL 0,4098
?L496:                                ;  endw
$DGL 0,4099
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,4100
                MOV        CR51,#69        ;  CR51=#69
$DGL 0,4101
                set1        tmcyc1.1        ;  set1 tmcyc1.1
$DGL 0,4102
?L497:                                ;  while_bit(!tmif51)     ;4.48ms
                BT        tmif51,$?L498
$DGL 0,4103
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L497
$DGL 0,4104
?L498:                                ;  endw
$DGL 0,4105
                clr1        tmif51        ;  clr1 tmif51

$DGL 0,4107
                MOV        a,#00011000B        ;  a=#00011000B
$DGL 0,4108
                call        !sendcode2        ;  call !sendcode2

$DGL 0,4110
                MOV        a,#11100111B        ;  a=#11100111B
$DGL 0,4111
                call        !sendcode2        ;  call !sendcode2
  
$DGL 0,4113
                MOVW        hl,#codebuffer        ;  hl=#codebuffer
$DGL 0,4114
                MOV        a,[hl]        ;  a=[hl]
$DGL 0,4115
                call        !sendcode2        ;  call !sendcode2
  
$DGL 0,4117
                MOVW        hl,#codebuffer        ;  hl=#codebuffer
$DGL 0,4118
                MOV        a,[hl]        ;  a=[hl]
$DGL 0,4119
                xor        a,#0FFH        ;  xor a,#0FFH
$DGL 0,4120
                call        !sendcode2        ;  call !sendcode2
  
$DGL 0,4122
                MOV        CR51,#8        ;  CR51=#8                ;0.576ms
$DGL 0,4123
                set1        tmcyc1.1        ;  set1 tmcyc1.1
$DGL 0,4124
?L499:                                ;  while_bit(!tmif51)
                BT        tmif51,$?L500
$DGL 0,4125
                MOV        WDTE,#0ACH        ;    WDTE=#0ACH
                BR        ?L499
$DGL 0,4126
?L500:                                ;  endw
$DGL 0,4127
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,4128
ret                                ;ret

$DGL 0,4130
sendcode2:                        ;sendcode2:
$DGL 0,4131
                MOV        c,#8        ;   c=#8
$DGL 0,4132
sendcode3:                        ;sendcode3:

$DGL 0,4134
                MOV        CR51,#8        ;  CR51=#8
$DGL 0,4135
                clr1        tmcyc1.1        ;  clr1 tmcyc1.1
$DGL 0,4136
?L501:                                ;  while_bit(!tmif51)
                BT        tmif51,$?L502
$DGL 0,4137
                MOV        WDTE,#0ACH        ;     WDTE=#0ACH
                BR        ?L501
$DGL 0,4138
?L502:                                ;  endw
$DGL 0,4139
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,4140
                rorc        a,1        ;  rorc a,1
$DGL 0,4141
                BC        $?L503        ;  if_bit(!cy)
$DGL 0,4142
                MOV        CR51,#8        ;    CR51=#8
                BR        ?L504
$DGL 0,4143
?L503:                                ;  else
$DGL 0,4144
                MOV        CR51,#25        ;    CR51=#25
$DGL 0,4145
?L504:                                ;  endif
$DGL 0,4146
                set1        tmcyc1.1        ;  set1 tmcyc1.1
$DGL 0,4147
?L505:                                ;  while_bit(!tmif51)
                BT        tmif51,$?L506
$DGL 0,4148
                MOV        WDTE,#0ACH        ;     WDTE=#0ACH
                BR        ?L505
$DGL 0,4149
?L506:                                ;  endw
$DGL 0,4150
                clr1        tmif51        ;  clr1 tmif51
$DGL 0,4151
                dbnz        c,$sendcode3        ;  dbnz c,$sendcode3
$DGL 0,4152
ret                                ;ret
                                                       ;--------------------------------------------------------------------
                                                       ; Processing name : BlockToAddress
                                                       ; Input : A = Block number
                                                       ; Output : AX = Block start address
                                                       ; Processing : A block number is calculated from block number.
                                                       ;--------------------------------------------------------------------
$DGL 0,4159
BlockToAddress:                        ;BlockToAddress:
$DGL 0,4160
MOV                X,#0                ;MOV X,#0
$DGL 0,4161
CLR1                CY                ;CLR1 CY
$DGL 0,4162
ROLC                A,1                ;ROLC A,1
$DGL 0,4163
ROLC                A,1                ;ROLC A,1
$DGL 0,4164
RET                                ;RET

$DGL 0,4166
_FlashStart:                        ;_FlashStart:
$DGL 0,4167
MOV                PFCMD,        #0A5H        ;MOV PFCMD, #0A5H                                                   ; PFCMD register control
$DGL 0,4168
MOV                FLPMC,        #001H        ;MOV FLPMC, #001H                                                   ; FLPMC register control ( set value )
$DGL 0,4169
MOV                FLPMC,        #0FEH        ;MOV FLPMC, #0FEH                                                   ; FLPMC register control ( inverted set value )
$DGL 0,4170
MOV                FLPMC,        #001H        ;MOV FLPMC, #001H                                                   ; FLPMC register control ( set value )
$DGL 0,4171
RET                                ;RET

$DGL 0,4173
_FlashEnd:                        ;_FlashEnd:
$DGL 0,4174
MOV                PFCMD,        #0A5H        ;MOV PFCMD, #0A5H                                                   ; PFCMD register control
$DGL 0,4175
MOV                FLPMC,        #000H        ;MOV FLPMC, #000H                                                   ; FLPMC register control ( set value )
$DGL 0,4176
MOV                FLPMC,        #0FFH        ;MOV FLPMC, #0FFH                                                   ; FLPMC register control ( inverted set value )
$DGL 0,4177
MOV                FLPMC,        #000H        ;MOV FLPMC, #000H                                                   ; FLPMC register control ( set value )
$DGL 0,4178
RET                                ;RET

$DGL 0,4180
_FlashEnv:                        ;_FlashEnv:
                                                                   ; Initialization processing
$DGL 0,4182
PUSH                PSW                ;PUSH PSW                                                           ; Save register bank in STACK.
$DGL 0,4183
PUSH                AX                ;PUSH AX
$DGL 0,4184
SEL                RB3                ;SEL RB3                                                            ; Sets to register bank 3.
$DGL 0,4185
POP                HL                ;POP HL                                                             ; Sets Entry RAM address to HL register
$DGL 0,4186
MOV                C,#FLASH_ENV        ;MOV C,#FLASH_ENV                                                   ; Sets function number to C register
$DGL 0,4187
CALL                !8100H                ;CALL !8100H                                                        ; Calls flash firmware
$DGL 0,4188
MOV                A,        #09H        ;MOV A, #09H
$DGL 0,4189
MOV                [HL+13H],        A        ;MOV [HL+13H], A                                                    ; Set Block Erase Retry Number
$DGL 0,4190
MOV                [HL+14H],        A        ;MOV [HL+14H], A                                                    ; Set Chip Erase Retry Number
$DGL 0,4191
POP                PSW                ;POP PSW                                                            ; Restores register bank from STACK.
$DGL 0,4192
RET                                ;RET

$DGL 0,4194
_FlashBlockErase:                ;_FlashBlockErase:
                                                                   ; Calculate Erase block number from block number and bank.
$DGL 0,4196
CALL                !ExchangeBlockNum        ;CALL !ExchangeBlockNum                                             ; Block number is calculated from block
                                                                   ; number and bank.
                                                                   ; ( Return A = Erase block number after it calculates )
$DGL 0,4199
BZ                $FBE_PErr        ;BZ $FBE_PErr                                                       ; It is error if the bank number is outside the range.
                                                                   ; Block erase processing
$DGL 0,4201
PUSH                PSW                ;PUSH PSW                                                           ; Save register bank in STACK.
$DGL 0,4202
PUSH                AX                ;PUSH AX
$DGL 0,4203
SEL                RB3                ;SEL RB3                                                            ; Sets to register bank 3.
$DGL 0,4204
POP                AX                ;POP AX
$DGL 0,4205
MOV                [HL+3],        A        ;MOV [HL+3], A                                                      ; Sets entry RAM+3 to Erase block number after
                                                                   ; it calculates
$DGL 0,4207
MOV                C,        #FLASH_BLOCK_ERASE        ;MOV C, #FLASH_BLOCK_ERASE                                          ; Sets function number to C register
$DGL 0,4208
CALL                !8100H                ;CALL !8100H                                                        ; Calls flash firmware
$DGL 0,4209
POP                PSW                ;POP PSW                                                            ; Restores register bank from STACK.
                                                                   ; Get flash firmware error information
$DGL 0,4211
MOV                A,        0FEE3H        ;MOV A, 0FEE3H                                                      ; Sets flash firmware error information to return value
                                                                   ; ( 0FEE3H = B register of Bank 3 )
$DGL 0,4213
BR                FlashBlockErase00        ;BR FlashBlockErase00
                                                                   ; Parameter error
$DGL 0,4215
FBE_PErr:                        ;FBE_PErr:
$DGL 0,4216
MOV                A,        #FLASHFIRM_PARAMETER_ERROR        ;MOV A, #FLASHFIRM_PARAMETER_ERROR                                  ; Sets parameter error to return
                                                                   ; value
$DGL 0,4218
FlashBlockErase00:                ;FlashBlockErase00:
$DGL 0,4219
RET                                ;RET

$DGL 0,4221
_FlashWordWrite:                ;_FlashWordWrite:
$DGL 0,4222
PUSH                DE                ;PUSH DE
                                                                   ; Calculate Writing address from writing address and bank.
$DGL 0,4224
CALL                !ExchangeAddress        ;CALL !ExchangeAddress                                              ; Writing address is calculated from structure
                                                                   ; member's writing address and bank
                                                                   ; ( Return AX = Writing address )
$DGL 0,4227
BZ                $FWW_PErr        ;BZ $FWW_PErr                                                       ; It is error if the bank number is outside
                                                                   ; the range.
                                                                   ; Word write processing
$DGL 0,4230
PUSH                PSW                ;PUSH PSW                                                           ; Save register bank in STACK.
$DGL 0,4231
PUSH                AX                ;PUSH AX
$DGL 0,4232
PUSH                BC                ;PUSH BC
$DGL 0,4233
PUSH                HL                ;PUSH HL
$DGL 0,4234
SEL                RB3                ;SEL RB3                                                            ; Sets to register bank 3.
$DGL 0,4235
POP                AX                ;POP AX
$DGL 0,4236
MOV                [HL+5],A        ;MOV [HL+5],A                                                       ; Sets entry RAM+5 to higher address in writing
                                                                   ; data buffer
$DGL 0,4238
MOV                A,X                ;MOV A,X
$DGL 0,4239
MOV                [HL+4],A        ;MOV [HL+4],A                                                       ; Sets entry RAM+4 to lower address in writing
                                                                   ; data buffer
$DGL 0,4241
POP                AX                ;POP AX
$DGL 0,4242
MOV                [HL+3],A        ;MOV [HL+3],A                                                       ; Sets entry RAM+3 to Number of writing data
$DGL 0,4243
MOV                A,X                ;MOV A,X
$DGL 0,4244
MOV                [HL+0],A        ;MOV [HL+0],A                                                       ; Sets entry RAM+0 to Writing address lower bytes
$DGL 0,4245
POP                AX                ;POP AX
$DGL 0,4246
MOV                [HL+2],A        ;MOV [HL+2],A                                                       ; Sets entry RAM+2 to Writing address most
                                                                   ; higher bytes
$DGL 0,4248
MOV                A,X                ;MOV A,X
$DGL 0,4249
MOV                [HL+1],A        ;MOV [HL+1],A                                                       ; Sets entry RAM+1 to Writing address higher bytes
$DGL 0,4250
MOV                C,#FLASH_WORD_WRITE        ;MOV C,#FLASH_WORD_WRITE                                            ; Sets function number to C register
$DGL 0,4251
CALL                !8100H                ;CALL !8100H                                                        ; Calls flash firmware
$DGL 0,4252
POP                PSW                ;POP PSW                                                            ; Restores register bank from STACK.
                                                                   ; Get flash firmware error information
$DGL 0,4254
MOV                A,0FEE3H        ;MOV A,0FEE3H                                                       ; Sets flash firmware error information to
                                                                   ; return value
                                                                   ; ( 0FEE3H = B register of Bank 3 )
$DGL 0,4257
BR                FlashWordWrite00        ;BR FlashWordWrite00
                                                                   ; Parameter error
$DGL 0,4259
FWW_PErr:                        ;FWW_PErr:
$DGL 0,4260
MOV                A,#FLASHFIRM_PARAMETER_ERROR        ;MOV A,#FLASHFIRM_PARAMETER_ERROR                                   ; Sets parameter error to return
                                                                   ; value
$DGL 0,4262
FlashWordWrite00:                ;FlashWordWrite00:
$DGL 0,4263
POP                DE                ;POP DE
$DGL 0,4264
RET                                ;RET

$DGL 0,4266
_FlashBlockVerify:                ;_FlashBlockVerify:
                                                                   ; Calculate Verify block number from block number and bank.
$DGL 0,4268
CALL                !ExchangeBlockNum        ;CALL !ExchangeBlockNum                                             ; Block number is calculated from block number
                                                                   ; and bank.
                                                                   ; ( Return A = Verify block number after it
                                                                   ; calculates )
$DGL 0,4272
BZ                $FBV_PErr        ;BZ $FBV_PErr                                                       ; It is error if the bank number is outside
                                                                   ; the range.
                                                                   ; Block verify processing
$DGL 0,4275
PUSH                PSW                ;PUSH PSW                                                           ; Save register bank in STACK.
$DGL 0,4276
PUSH                AX                ;PUSH AX
$DGL 0,4277
SEL                RB3                ;SEL RB3                                                            ; Sets to register bank 3.
$DGL 0,4278
POP                AX                ;POP AX
$DGL 0,4279
MOV                [HL+3],        A        ;MOV [HL+3], A                                                      ; Sets entry RAM+3 to Verify block number
                                                                   ; after it calculates
$DGL 0,4281
MOV                C,        #FLASH_BLOCK_VERIFY        ;MOV C, #FLASH_BLOCK_VERIFY                                         ; Sets function number to C register
$DGL 0,4282
CALL                !8100H                ;CALL !8100H                                                        ; Calls flash firmware
$DGL 0,4283
POP                PSW                ;POP PSW                                                            ; Restores register bank from STACK.
                                                                   ; Get flash firmware error information
$DGL 0,4285
MOV                A,        0FEE3H        ;MOV A, 0FEE3H                                                      ; Sets flash firmware error information to return value
                                                                   ; ( 0FEE3H = B register of Bank 3 )
$DGL 0,4287
BR                FlashBlockVerify00        ;BR FlashBlockVerify00
                                                                   ; Parameter error
$DGL 0,4289
FBV_PErr:                        ;FBV_PErr:
$DGL 0,4290
MOV                A,        #FLASHFIRM_PARAMETER_ERROR        ;MOV A, #FLASHFIRM_PARAMETER_ERROR                                  ; Sets parameter error to return
                                                                   ; value
$DGL 0,4292
FlashBlockVerify00:                ;FlashBlockVerify00:
$DGL 0,4293
RET                                ;RET

$DGL 0,4295
_FlashBlockBlankCheck:                ;_FlashBlockBlankCheck:
                                                                   ; Calculate Blank check block number from block number and bank.
$DGL 0,4297
CALL                !ExchangeBlockNum        ;CALL !ExchangeBlockNum                                             ; Block number is calculated from block number
                                                                   ; and bank.
                                                                   ; ( Return A = Blank check block number after
                                                                   ; it calculates )
$DGL 0,4301
BZ                $FBBC_PErr        ;BZ $FBBC_PErr                                                      ; It is error if the bank number is outside
                                                                   ; the range.
                                                                   ; Block blank check processing
$DGL 0,4304
PUSH                PSW                ;PUSH PSW                                                           ; Save register bank in STACK.
$DGL 0,4305
PUSH                AX                ;PUSH AX
$DGL 0,4306
SEL                RB3                ;SEL RB3                                                            ; Sets to register bank 3.
$DGL 0,4307
POP                AX                ;POP AX
$DGL 0,4308
MOV                [HL+3],        A        ;MOV [HL+3], A                                                      ; Sets entry RAM+3 to Blank check
                                                                   ; block number after it calculates
$DGL 0,4310
MOV                C,        #FLASH_BLOCK_BLANKCHECK        ;MOV C, #FLASH_BLOCK_BLANKCHECK                                     ; Sets function number to C register
$DGL 0,4311
CALL                !8100H                ;CALL !8100H                                                        ; Calls flash firmware
$DGL 0,4312
POP                PSW                ;POP PSW                                                            ; Restores register bank from STACK.
                                                                   ; Get flash firmware error information
$DGL 0,4314
MOV                A,        0FEE3H        ;MOV A, 0FEE3H                                                      ; Sets flash firmware error information to return value
                                                                   ; ( 0FEE3H = B register of Bank 3 )
$DGL 0,4316
BR                FlashBlockBlankCheck00        ;BR FlashBlockBlankCheck00
                                                                   ; Parameter error
$DGL 0,4318
FBBC_PErr:                        ;FBBC_PErr:
$DGL 0,4319
MOV                A,        #FLASHFIRM_PARAMETER_ERROR        ;MOV A, #FLASHFIRM_PARAMETER_ERROR                                  ; Sets parameter error to return
                                                                   ; value
$DGL 0,4321
FlashBlockBlankCheck00:                ;FlashBlockBlankCheck00:
$DGL 0,4322
RET                                ;RET

$DGL 0,4324
_CheckFLMD:                        ;_CheckFLMD:
                                                                   ; Set information processing
$DGL 0,4326
PUSH                PSW                ;PUSH PSW                                                           ; Save register bank in STACK.
$DGL 0,4327
SEL                RB3                ;SEL RB3                                                            ; Sets to register bank 3.
$DGL 0,4328
MOV                C,        #FLASH_CHECK_FLMD        ;MOV C, #FLASH_CHECK_FLMD                                           ; Sets function number to C register
$DGL 0,4329
CALL                !8100H                ;CALL !8100H                                                        ; Calls flash firmware
$DGL 0,4330
POP                PSW                ;POP PSW                                                            ; Restores register bank from STACK.
                                                                   ; Get flash firmware error information
$DGL 0,4332
MOV                A,        0FEE3H        ;MOV A, 0FEE3H                                                      ; Sets flash firmware error information to return value
                                                                   ; ( 0FEE3H = B register of Bank 3 )
$DGL 0,4334
RET                                ;RET

$DGL 0,4336
_EEPROMWrite:                        ;_EEPROMWrite:
$DGL 0,4337
PUSH                DE                ;PUSH DE
                                                                   ; Calculate Writing address from writing address and bank.
$DGL 0,4339
CALL                !ExchangeAddress        ;CALL !ExchangeAddress                                              ; Writing address is calculated from structure
                                                                   ; member's writing address and bank
                                                                   ; ( Return AX = Writing address )
$DGL 0,4342
BZ                $EW_PErr        ;BZ $EW_PErr                                                        ; It is error if the bank number is outside the range.
                                                                   ; EEPROM write processing
$DGL 0,4344
PUSH                PSW                ;PUSH PSW                                                           ; Save register bank in STACK.
$DGL 0,4345
PUSH                AX                ;PUSH AX
$DGL 0,4346
PUSH                BC                ;PUSH BC
$DGL 0,4347
PUSH                HL                ;PUSH HL
$DGL 0,4348
SEL                RB3                ;SEL RB3                                                            ; Sets to register bank 3.
$DGL 0,4349
POP                AX                ;POP AX
$DGL 0,4350
MOV                [HL+5],        A        ;MOV [HL+5], A                                                      ; Sets entry RAM+5 to higher address in writing data
                                                                   ;buffer
$DGL 0,4352
MOV                A,X                ;MOV A,X
$DGL 0,4353
MOV                [HL+4],        A        ;MOV [HL+4], A                                                      ; Sets entry RAM+4 to lower address in writing data
                                                                   ;buffer
$DGL 0,4355
POP                AX                ;POP AX
$DGL 0,4356
MOV                [HL+3],        A        ;MOV [HL+3], A                                                      ; Sets entry RAM+3 to Number of writing data
$DGL 0,4357
MOV                A,X                ;MOV A,X
$DGL 0,4358
MOV                [HL+0],        A        ;MOV [HL+0], A                                                      ; Sets entry RAM+0 to Writing address lower bytes
$DGL 0,4359
POP                AX                ;POP AX
$DGL 0,4360
MOV                [HL+2],        A        ;MOV [HL+2], A                                                      ; Sets entry RAM+2 to Writing address most higher bytes
$DGL 0,4361
MOV                A,        X        ;MOV A, X
$DGL 0,4362
MOV                [HL+1],        A        ;MOV [HL+1], A                                                      ; Sets entry RAM+1 to Writing address higher bytes
$DGL 0,4363
MOV                C,        #FLASH_EEPROM_WRITE        ;MOV C, #FLASH_EEPROM_WRITE                                         ; Sets function number to C register
$DGL 0,4364
CALL                !8100H                ;CALL !8100H                                                        ; Calls flash firmware
$DGL 0,4365
POP                PSW                ;POP PSW                                                            ; Restores register bank from STACK.
                                                                   ;Get flash firmware error information
$DGL 0,4367
MOV                A,0FEE3H        ;MOV A,0FEE3H                                                       ;Sets flash firmware error information to return
                                                                   ;value
                                                                   ;(0FEE3H = B register of Bank 3)
$DGL 0,4370
BR                EEPROMWrite00        ;BR EEPROMWrite00
                                                                   ; Parameter error
$DGL 0,4372
EW_PErr:                        ;EW_PErr:
$DGL 0,4373
MOV                A,        #FLASHFIRM_PARAMETER_ERROR        ;MOV A, #FLASHFIRM_PARAMETER_ERROR                                  ; Sets parameter error to return
                                                                   ; value
$DGL 0,4375
EEPROMWrite00:                        ;EEPROMWrite00:
$DGL 0,4376
POP                DE                ;POP DE
$DGL 0,4377
RET                                ;RET

$DGL 0,4379
ExchangeBlockNum:                ;ExchangeBlockNum:
                                                                   ; It calculates from 32 to 47 block number.
$DGL 0,4381
XCH                A,        B        ;XCH A, B
$DGL 0,4382
CMP                A,        #32        ;CMP A, #32
$DGL 0,4383
BC                $EBN_end        ;BC $EBN_end
$DGL 0,4384
CMP                A,        #48        ;CMP A, #48
$DGL 0,4385
BNC                $EBN_end        ;BNC $EBN_end
                                                                   ; Calculation of block number( Bank*16 is added to block number. )
$DGL 0,4387
XCH                A,        B        ;XCH A, B
$DGL 0,4388
MOV                C,        A        ;MOV C, A                                                           ; C ... Bank
$DGL 0,4389
CMP                A,        #6        ;CMP A, #6
$DGL 0,4390
BNC                $EBN_error_end        ;BNC $EBN_error_end
$DGL 0,4391
ROL                A,        1        ;ROL A, 1
$DGL 0,4392
ROL                A,        1        ;ROL A, 1
$DGL 0,4393
ROL                A,        1        ;ROL A, 1
$DGL 0,4394
ROL                A,        1        ;ROL A, 1                                                           ; A = 16*Bank
$DGL 0,4395
ADD                A,        B        ;ADD A, B
$DGL 0,4396
XCH                A,        C        ;XCH A, C
$DGL 0,4397
XCH                A,        B        ;XCH A, B
$DGL 0,4398
XCH                A,        C        ;XCH A, C                                                           ; A = Block number after it calculates, B = Bank,
                                                                   ; C = Block number before it calculates
$DGL 0,4400
BR                EBN_end                ;BR EBN_end
                                                                   ; Bank error
$DGL 0,4402
EBN_error_end:                        ;EBN_error_end:
$DGL 0,4403
MOV                A,        #BANK_BLC_ERROR        ;MOV A, #BANK_BLC_ERROR                                             ; Return error number
$DGL 0,4404
EBN_end:                        ;EBN_end:
$DGL 0,4405
CMP                A,#BANK_BLC_ERROR        ;CMP A,#BANK_BLC_ERROR                                              ;Bank error ?
$DGL 0,4406
RET                                ;RET

$DGL 0,4408
ExchangeAddress:                ;ExchangeAddress:
$DGL 0,4409
PUSH                HL                ;PUSH HL
                                                                   ; It calculates from 8000H to BFFFH address.
$DGL 0,4411
MOVW                HL,        AX        ;MOVW HL, AX
$DGL 0,4412
MOV                A,        [HL+0]                                                      ; Read data from writing beginning address        ;MOV A, [HL+0]                                                      ; Read data from writing beginning address
                                                                   ; structure( =Write address )
$DGL 0,4414
MOV                X,        A        ;MOV X, A
$DGL 0,4415
MOV                A,        [HL+1]        ;MOV A, [HL+1]
$DGL 0,4416
CMPW                AX,        #8000H        ;CMPW AX, #8000H
$DGL 0,4417
BC                $EA_end                ;BC $EA_end
$DGL 0,4418
CMPW                AX,        #0C000H        ;CMPW AX, #0C000H
$DGL 0,4419
BNC                $EA_end                ;BNC $EA_end
                                                                   ; Calculation of address( Bank*40H is added to address in two high rank bytes.
                                                                   ; Lower address is the state as it is. )
$DGL 0,4422
MOV                D,        A        ;MOV D, A
$DGL 0,4423
XCH                A,        X        ;XCH A, X
$DGL 0,4424
MOV                C,        A        ;MOV C, A
$DGL 0,4425
MOV                X,        #0        ;MOV X, #0
$DGL 0,4426
MOV                A,        [HL+2]                                                      ; Read data from writing beginning address        ;MOV A, [HL+2]                                                      ; Read data from writing beginning address
                                                                   ; structure
$DGL 0,4428
CMP                A,        #6        ;CMP A, #6
$DGL 0,4429
BNC                $EA_error_end        ;BNC $EA_error_end
$DGL 0,4430
ROL                A,        1        ;ROL A, 1
$DGL 0,4431
ROL                A,        1        ;ROL A, 1
$DGL 0,4432
ROL                A,        1        ;ROL A, 1
$DGL 0,4433
ROL                A,        1        ;ROL A, 1
$DGL 0,4434
ROL                A,        1        ;ROL A, 1
$DGL 0,4435
ROLC                A,        1        ;ROLC A, 1
$DGL 0,4436
XCH                A,        X        ;XCH A, X
$DGL 0,4437
ROLC                A,        1        ;ROLC A, 1                                                          ; AX = 40H*Bank
$DGL 0,4438
XCH                A,        X        ;XCH A, X
$DGL 0,4439
ADD                A,        D        ;ADD A, D                                                           ; Addition of Higher address
$DGL 0,4440
XCH                A,        X        ;XCH A, X
$DGL 0,4441
ADDC                A,        #0        ;ADDC A, #0                                                         ; Addition of Most higher address
                                                                   ; A ... Most higher address after it calculates
                                                                   ; X ... higher address after it calculates,
                                                                   ; C ... Lower address
$DGL 0,4445
BR                EA_normal_end        ;BR EA_normal_end
                                                                   ; Bank error
$DGL 0,4447
EA_error_end:                        ;EA_error_end:
$DGL 0,4448
MOVW                AX,        #BANK_ADDR_ERROR        ;MOVW AX, #BANK_ADDR_ERROR
$DGL 0,4449
BR                EA_normal_end        ;BR EA_normal_end
$DGL 0,4450
EA_end:                                ;EA_end:
$DGL 0,4451
XCH                A,        X        ;XCH A, X
$DGL 0,4452
MOV                C,        A        ;MOV C, A
$DGL 0,4453
MOV                A,        #0        ;MOV A, #0                                                          ; A ... Most higher address after it calculates
                                                                   ; X ... higher address after it calculates,
                                                                   ; C...Lower address
$DGL 0,4456
EA_normal_end:                        ;EA_normal_end:
$DGL 0,4457
POP                HL                ;POP HL
$DGL 0,4458
CMPW                AX,        #BANK_ADDR_ERROR        ;CMPW AX, #BANK_ADDR_ERROR                                          ; Bank error?
$DGL 0,4459
ret                                ;ret

$DGL 0,4461
deRC_6sub:                        ;deRC_6sub:   
$DGL 0,4462
                MOVW        hl,#EEPROMBuf        ;   hl=#EEPROMBuf
$DGL 0,4463
                INCW        hl        ;   hl++
$DGL 0,4464
                INCW        hl        ;   hl++
$DGL 0,4465
                INCW        hl        ;   hl++
$DGL 0,4466
                MOV        i,#0        ;   i=#0
$DGL 0,4467
                clr1        case1        ;   clr1 case1
$DGL 0,4468
                clr1        case2        ;   clr1 case2
$DGL 0,4469
                clr1        cy        ;      clr1 cy
$DGL 0,4470
                MOV        a,l        ;      l+=#6,cy(a)
                ADDC        a,#6
                MOV        l,a
$DGL 0,4471
                MOV        a,h        ;      h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,4472
                MOV        a,[hl]        ;      a=[hl]
$DGL 0,4473
                MOV        x,a        ;      x=a
$DGL 0,4474
                INCW        hl        ;      hl++
$DGL 0,4475
                MOV        a,[hl]        ;      a=[hl]
$DGL 0,4476
                MOVW        tempdata,ax        ;      tempdata=ax
$DGL 0,4477
                MOVW        ax,tempdata        ;      if((tempdata>=#3256)&&(tempdata<=#3856))(ax)
                CMPW        ax,#3256
                BC        $?L507
                MOVW        ax,tempdata
                CMPW        ax,#3856
                BZ        $$+4
                BNC        $?L507
$DGL 0,4478
                set1        case1        ;        set1 case1
                BR        ?L508
$DGL 0,4479
?L507:                                ;      else
$DGL 0,4480
                MOVW        ax,tempdata        ;        if((tempdata>=#1478)&&(tempdata<=#2200))(ax)
                CMPW        ax,#1478
                BC        $?L509
                MOVW        ax,tempdata
                CMPW        ax,#2200
                BZ        $$+4
                BNC        $?L509
$DGL 0,4481
                set1        case2        ;          set1 case2
$DGL 0,4482
?L509:                                ;        endif
$DGL 0,4483
?L508:                                ;      endif
$DGL 0,4484
                INCW        hl        ;      hl++
$DGL 0,4485
RC_6code:                        ;RC_6code:
$DGL 0,4486
                MOV        a,[hl]        ;      a=[hl]
$DGL 0,4487
                MOV        x,a        ;      x=a
$DGL 0,4488
                INCW        hl        ;      hl++
$DGL 0,4489
                MOV        a,[hl]        ;      a=[hl]
$DGL 0,4490
                MOVW        tempdata,ax        ;      tempdata=ax
$DGL 0,4491
                MOVW        ax,tempdata        ;      if((tempdata>=#3256)&&(tempdata<=#3856))(ax)
                CMPW        ax,#3256
                BC        $?L510
                MOVW        ax,tempdata
                CMPW        ax,#3856
                BZ        $$+4
                BNC        $?L510
$DGL 0,4492
                MOVW        bc,#3556        ;        bc=#3556
                BR        ?L511
$DGL 0,4493
?L510:                                ;      else
$DGL 0,4494
                MOVW        ax,tempdata        ;        if((tempdata>=#1478)&&(tempdata<=#2200))(ax)
                CMPW        ax,#1478
                BC        $?L512
                MOVW        ax,tempdata
                CMPW        ax,#2200
                BZ        $$+4
                BNC        $?L512
$DGL 0,4495
                MOVW        bc,#1778        ;          bc=#1778
                BR        ?L513
$DGL 0,4496
?L512:                                ;        else
$DGL 0,4497
                MOVW        ax,tempdata        ;          if((tempdata>=#5000)&&(tempdata<=#5700))(ax)
                CMPW        ax,#5000
                BC        $?L514
                MOVW        ax,tempdata
                CMPW        ax,#5700
                BZ        $$+4
                BNC        $?L514
$DGL 0,4498
                MOVW        bc,#5334        ;             bc=#5334
$DGL 0,4499
                MOVW        ax,sum        ;             ax=sum
$DGL 0,4500
                call        !twobytes_add        ;             call !twobytes_add
$DGL 0,4501
                BF        case1,$?L515        ;             if_bit(case1)
$DGL 0,4502
                CMPW        ax,#16002        ;               if(ax>=#16002)
                BC        $?L516
$DGL 0,4503
                MOVW        bc,#3556        ;                  bc=#3556
$DGL 0,4504
?L516:                                ;               endif
                BR        ?L517
$DGL 0,4505
?L515:                                ;             else
$DGL 0,4506
                BF        case2,$?L518        ;               if_bit(case2)
$DGL 0,4507
                CMPW        ax,#17780        ;                 if(ax>=#17780)
                BC        $?L519
$DGL 0,4508
                MOVW        bc,#3556        ;                   bc=#3556
$DGL 0,4509
?L519:                                ;                 endif
$DGL 0,4510
?L518:                                ;               endif
$DGL 0,4511
?L517:                                ;             endif
$DGL 0,4512
?L514:                                ;          endif
$DGL 0,4513
?L513:                                ;        endif
$DGL 0,4514
?L511:                                ;      endif
$DGL 0,4515
                MOVW        ax,sum        ;      ax=sum
$DGL 0,4516
                call        !twobytes_add        ;      call !twobytes_add
$DGL 0,4517
                MOVW        sum,ax        ;      sum=ax
$DGL 0,4518
                INCW        hl        ;      hl++
$DGL 0,4519
                INC        i        ;      i++
$DGL 0,4520
                MOVW        ax,sum        ;      ax=sum
$DGL 0,4521
                BF        case1,$?L520        ;      if_bit(case1)
$DGL 0,4522
                cmpw        ax,#16002        ;        cmpw ax,#16002
                BR        ?L521
$DGL 0,4523
?L520:                                ;      else
$DGL 0,4524
                BF        case2,$?L522        ;        if_bit(case2)
$DGL 0,4525
                cmpw        ax,#17780        ;          cmpw ax,#17780
$DGL 0,4526
?L522:                                ;        endif
$DGL 0,4527
?L521:                                ;      endif
$DGL 0,4528
                bnz        $RC_6code        ;      bnz $RC_6code
$DGL 0,4529
                clr1        case1        ;      clr1 case1
$DGL 0,4530
                clr1        case2        ;      clr1 case2
   
$DGL 0,4532
                MOVW        hl,#EEPROMBuf        ;   hl=#EEPROMBuf
$DGL 0,4533
                INCW        hl        ;   hl++
$DGL 0,4534
                INCW        hl        ;   hl++
$DGL 0,4535
                INCW        hl        ;   hl++
$DGL 0,4536
                MOV        a,i        ;   a=i
$DGL 0,4537
                BT        a.0,$?L523        ;   IF_BIT(a.0)
                BR        ?L524
?L523:
$DGL 0,4538
                clr1        cy        ;     clr1 cy
$DGL 0,4539
                addc        a,#3        ;     addc a,#3
$DGL 0,4540
                rol        a,1        ;     rol a,1
$DGL 0,4541
                and        a,#11111110b        ;     and a,#11111110b
$DGL 0,4542
                MOV        b,a        ;     b=a
$DGL 0,4543
                MOV        a,[hl+b]        ;     a=[hl+b]
$DGL 0,4544
                MOV        x,a        ;     x=a
$DGL 0,4545
                INC        b        ;     b++
$DGL 0,4546
                MOV        a,[hl+b]        ;     a=[hl+b]
$DGL 0,4547
                MOVW        pls_high,ax        ;     pls_high=ax
$DGL 0,4548
                DEC        b        ;     b--
$DGL 0,4549
                DEC        b        ;     b--
$DGL 0,4550
                DEC        b        ;     b--
$DGL 0,4551
                MOV        a,[hl+b]        ;     a=[hl+b]
$DGL 0,4552
                MOV        x,a        ;     x=a
$DGL 0,4553
                INC        b        ;     b++
$DGL 0,4554
                push        bc        ;     push bc           ;寧轀u弝
$DGL 0,4555
                MOV        a,[hl+b]        ;     a=[hl+b]
$DGL 0,4556
                MOVW        pls_low,ax        ;     pls_low=ax
$DGL 0,4557
                MOVW        ax,pls_low        ;     bc=pls_low(ax)
                MOVW        bc,ax
$DGL 0,4558
                MOVW        ax,pls_high        ;     ax=pls_high
$DGL 0,4559
                call        !twobyte_subtract        ;     call !twobyte_subtract
$DGL 0,4560
                BNC        $?L525        ;     if_bit(cy)
$DGL 0,4561
                MOVW        ax,pls_high        ;       bc=pls_high(ax)
                MOVW        bc,ax
$DGL 0,4562
                MOVW        ax,pls_low        ;       ax=pls_low
$DGL 0,4563
                call        !twobyte_subtract        ;       call !twobyte_subtract
$DGL 0,4564
?L525:                                ;     endif
$DGL 0,4565
                CMPW        ax,#1200        ;     IF(ax<=#1200)
                BZ        $?L526
                BC        $?L526
                BR        ?L527
?L526:
$DGL 0,4566
                MOVW        ax,pls_high        ;       IF(pls_high>=#5000)(ax)
                CMPW        ax,#5000
                BNC        $?L528
                BR        ?L529
?L528:
$DGL 0,4567
                MOVW        ax,pls_low        ;         ax=pls_low
$DGL 0,4568
                MOVW        bc,#3556        ;         bc=#3556
$DGL 0,4569
                call        !twobyte_subtract        ;         call !twobyte_subtract
$DGL 0,4570
                pop        bc        ;         pop bc
$DGL 0,4571
                MOV        [hl+b],a        ;         [hl+b]=a
$DGL 0,4572
                DEC        b        ;         b--
$DGL 0,4573
                MOV        a,x        ;         [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4574
                INC        b        ;         b++
$DGL 0,4575
                INC        b        ;         b++
$DGL 0,4576
                INC        b        ;         b++
$DGL 0,4577
                push        bc        ;         push bc
$DGL 0,4578
                MOVW        ax,pls_high        ;         ax=pls_high
$DGL 0,4579
                MOVW        bc,#3556        ;         bc=#3556
$DGL 0,4580
                call        !twobyte_subtract        ;         call !twobyte_subtract
$DGL 0,4581
                pop        bc        ;         pop bc
$DGL 0,4582
                MOV        [hl+b],a        ;         [hl+b]=a
$DGL 0,4583
                DEC        b        ;         b--
$DGL 0,4584
                MOV        a,x        ;         [hl+b]=x(a)                  ;泿謽幚妿霂Y妳曽弾蹟?
                MOV        [hl+b],a
         
$DGL 0,4586
                MOV        a,counter        ;         a=counter
$DGL 0,4587
                DEC        a        ;         a--
$DGL 0,4588
                clr1        cy        ;         clr1 cy
$DGL 0,4589
                rol        a,1        ;         rol a,1
$DGL 0,4590
                and        a,#11111110b        ;         and a,#11111110b
$DGL 0,4591
                MOV        j,a        ;         j=a
$DGL 0,4592
                DEC        j        ;         j--
$DGL 0,4593
                MOV        a,i        ;         a=i
$DGL 0,4594
                clr1        cy        ;         clr1 cy
$DGL 0,4595
                addc        a,#3        ;         addc a,#3
$DGL 0,4596
                clr1        cy        ;         clr1 cy
$DGL 0,4597
                rol        a,1        ;         rol a,1
$DGL 0,4598
                and        a,#11111110b        ;         and a,#11111110b
$DGL 0,4599
                DEC        a        ;         a--
$DGL 0,4600
                MOV        temp,a        ;         temp=a
$DGL 0,4601
RC_6code1:                        ;RC_6code1:
$DGL 0,4602
                MOVW        hl,#EEPROMBuf        ;           hl=#EEPROMBuf
$DGL 0,4603
                INCW        hl        ;           hl++
$DGL 0,4604
                INCW        hl        ;           hl++
$DGL 0,4605
                INCW        hl        ;           hl++
$DGL 0,4606
                MOV        a,l        ;           l+=j,cy(a)
                ADDC        a,j
                MOV        l,a
$DGL 0,4607
                MOV        a,h        ;           h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,4608
                MOV        a,[hl]        ;           a=[hl]
$DGL 0,4609
                MOV        [hl+4],a        ;           [hl+4]=a
$DGL 0,4610
                DEC        j        ;           j--
$DGL 0,4611
                MOV        a,temp        ;           a=temp
$DGL 0,4612
                cmp        a,j        ;           cmp a,j
$DGL 0,4613
                bnc        $RC_6code1        ;           bnc $RC_6code1
         
$DGL 0,4615
                MOVW        bc,#3556        ;           bc=#3556
$DGL 0,4616
                MOV        a,c        ;           [hl]=c(a)
                MOV        [hl],a
$DGL 0,4617
                INCW        hl        ;           hl++
$DGL 0,4618
                MOV        a,b        ;           [hl]=b(a)
                MOV        [hl],a
$DGL 0,4619
                INCW        hl        ;           hl++
$DGL 0,4620
                MOV        a,c        ;           [hl]=c(a)
                MOV        [hl],a
$DGL 0,4621
                INCW        hl        ;           hl++
$DGL 0,4622
                MOV        a,b        ;           [hl]=b(a)
                MOV        [hl],a
$DGL 0,4623
                MOV        a,counter        ;           a=counter
$DGL 0,4624
                INC        a        ;           a++
$DGL 0,4625
                INC        a        ;           a++
$DGL 0,4626
                MOV        counter,a        ;           counter=a
$DGL 0,4627
                ret                ;           ret
                BR        ?L530
$DGL 0,4628
?L529:                                ;       ELSE
$DGL 0,4629
                MOVW        ax,pls_high        ;         IF(pls_high>=#3200)(ax)
                CMPW        ax,#3200
                BNC        $?L531
                BR        ?L532
?L531:
$DGL 0,4630
                pop        bc        ;            pop bc
$DGL 0,4631
                DEC        b        ;            b--
$DGL 0,4632
                DEC        b        ;            b--
$DGL 0,4633
                DEC        b        ;            b--
$DGL 0,4634
                MOV        a,[hl+b]        ;            x=[hl+b](a)
                MOV        x,a
$DGL 0,4635
                INC        b        ;            b++                 ;寧轀u弝
$DGL 0,4636
                MOV        a,[hl+b]        ;            a=[hl+b]
            
$DGL 0,4638
                push        bc        ;            push bc
$DGL 0,4639
                MOVW        bc,#3556        ;            bc=#3556
$DGL 0,4640
                call        !twobytes_add        ;            call !twobytes_add
$DGL 0,4641
                pop        bc        ;            pop bc
$DGL 0,4642
                MOV        [hl+b],a        ;            [hl+b]=a
$DGL 0,4643
                DEC        b        ;            b--
$DGL 0,4644
                MOV        a,x        ;            [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4645
                INC        b        ;            b++
$DGL 0,4646
                INC        b        ;            b++
$DGL 0,4647
                INC        b        ;            b++
$DGL 0,4648
                MOVW        ax,#5334        ;            ax=#5334
$DGL 0,4649
                MOV        [hl+b],a        ;            [hl+b]=a
$DGL 0,4650
                DEC        b        ;            b--
$DGL 0,4651
                MOV        a,x        ;            [hl+b]=x(a)
                MOV        [hl+b],a
            
$DGL 0,4653
                INC        b        ;            b++
$DGL 0,4654
                INC        b        ;            b++
$DGL 0,4655
                MOV        a,#0        ;            [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,4656
                INC        b        ;            b++
$DGL 0,4657
                MOV        a,#0        ;            [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,4658
                INC        b        ;            b++
$DGL 0,4659
                MOV        a,#0        ;            [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,4660
                INC        b        ;            b++
$DGL 0,4661
                MOV        a,#0        ;            [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,4662
                ret                ;            ret
$DGL 0,4663
?L532:                                ;         ENDIF
$DGL 0,4664
?L530:                                ;       ENDIF  
                BR        ?L533
$DGL 0,4665
?L527:                                ;     ELSE
$DGL 0,4666
                MOVW        ax,pls_high        ;       IF(pls_high>=#5000)(ax)
                CMPW        ax,#5000
                BNC        $?L534
                BR        ?L535
?L534:
$DGL 0,4667
                pop        bc        ;           pop bc
$DGL 0,4668
                DEC        b        ;           b--
$DGL 0,4669
                DEC        b        ;           b--
$DGL 0,4670
                DEC        b        ;           b--
$DGL 0,4671
                MOV        a,[hl+b]        ;           x=[hl+b](a)
                MOV        x,a
$DGL 0,4672
                INC        b        ;           b++
$DGL 0,4673
                MOV        a,[hl+b]        ;           a=[hl+b]
$DGL 0,4674
                push        bc        ;           push bc                ;寧轀u弝
           
$DGL 0,4676
                MOVW        bc,#3556        ;           bc=#3556
$DGL 0,4677
                call        !twobytes_add        ;           call !twobytes_add
$DGL 0,4678
                pop        bc        ;           pop bc
$DGL 0,4679
                MOV        [hl+b],a        ;           [hl+b]=a
$DGL 0,4680
                DEC        b        ;           b--
$DGL 0,4681
                MOV        a,x        ;           [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4682
                INC        b        ;           b++
$DGL 0,4683
                INC        b        ;           b++
$DGL 0,4684
                INC        b        ;           b++
$DGL 0,4685
                MOVW        ax,#3556        ;           ax=#3556
$DGL 0,4686
                MOV        [hl+b],a        ;           [hl+b]=a
$DGL 0,4687
                DEC        b        ;           b--
$DGL 0,4688
                MOV        a,x        ;           [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4689
                INC        b        ;           b++
$DGL 0,4690
                INC        b        ;           b++
$DGL 0,4691
                MOV        a,[hl+b]        ;           x=[hl+b](a)
                MOV        x,a
$DGL 0,4692
                INC        b        ;           b++
$DGL 0,4693
                MOV        a,[hl+b]        ;           a=[hl+b]
$DGL 0,4694
                push        bc        ;           push bc
           
$DGL 0,4696
                MOVW        bc,#3556        ;           bc=#3556
$DGL 0,4697
                call        !twobytes_add        ;           call !twobytes_add
$DGL 0,4698
                pop        bc        ;           pop bc
$DGL 0,4699
                MOV        [hl+b],a        ;           [hl+b]=a
$DGL 0,4700
                DEC        b        ;           b--
$DGL 0,4701
                MOV        a,x        ;           [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4702
                ret                ;           ret
                BR        ?L536
$DGL 0,4703
?L535:                                ;       ELSE
$DGL 0,4704
                MOVW        ax,pls_high        ;         IF(pls_high>=#3200)(ax)
                CMPW        ax,#3200
                BNC        $?L537
                BR        ?L538
?L537:
$DGL 0,4705
                MOVW        ax,pls_low        ;           ax=pls_low
$DGL 0,4706
                MOVW        bc,#3556        ;           bc=#3556
$DGL 0,4707
                call        !twobyte_subtract        ;           call !twobyte_subtract
$DGL 0,4708
                pop        bc        ;           pop bc
$DGL 0,4709
                MOV        [hl+b],a        ;           [hl+b]=a
$DGL 0,4710
                DEC        b        ;           b--
$DGL 0,4711
                MOV        a,x        ;           [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4712
                INC        b        ;           b++
$DGL 0,4713
                INC        b        ;           b++
$DGL 0,4714
                INC        b        ;           b++
$DGL 0,4715
                MOVW        ax,#3556        ;           ax=#3556
$DGL 0,4716
                MOV        [hl+b],a        ;           [hl+b]=a
$DGL 0,4717
                DEC        b        ;           b--
$DGL 0,4718
                MOV        a,x        ;           [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4719
                INC        b        ;           b++
$DGL 0,4720
                INC        b        ;           b++
$DGL 0,4721
                MOV        a,[hl+b]        ;           x=[hl+b](a)
                MOV        x,a
$DGL 0,4722
                INC        b        ;           b++
$DGL 0,4723
                push        bc        ;           push bc                    ;寧轀u弝
$DGL 0,4724
                MOV        a,[hl+b]        ;           a=[hl+b]
           
$DGL 0,4726
                MOVW        bc,#3556        ;           bc=#3556
$DGL 0,4727
                call        !twobytes_add        ;           call !twobytes_add
$DGL 0,4728
                pop        bc        ;           pop bc
$DGL 0,4729
                MOV        [hl+b],a        ;           [hl+b]=a
$DGL 0,4730
                DEC        b        ;           b--
$DGL 0,4731
                MOV        a,x        ;           [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4732
?L538:                                ;         ENDIF
$DGL 0,4733
?L536:                                ;       ENDIF  
$DGL 0,4734
?L533:                                ;     ENDIF
                BR        ?L539
$DGL 0,4735
?L524:                                ;   ELSE
$DGL 0,4736
                BF        a.0,$?L540        ;     IF_BIT(!a.0)
                BR        ?L541
?L540:
$DGL 0,4737
                clr1        cy        ;       clr1 cy
$DGL 0,4738
                addc        a,#3        ;       addc a,#3
$DGL 0,4739
                rol        a,1        ;       rol a,1
$DGL 0,4740
                and        a,#11111110b        ;       and a,#11111110b
$DGL 0,4741
                MOV        b,a        ;       b=a
$DGL 0,4742
                MOV        a,[hl+b]        ;       a=[hl+b]
$DGL 0,4743
                MOV        x,a        ;       x=a
$DGL 0,4744
                INC        b        ;       b++
$DGL 0,4745
                MOV        a,[hl+b]        ;       a=[hl+b]
$DGL 0,4746
                MOVW        pls_low,ax        ;       pls_low=ax
$DGL 0,4747
                DEC        b        ;       b--
$DGL 0,4748
                DEC        b        ;       b--
$DGL 0,4749
                DEC        b        ;       b--
$DGL 0,4750
                MOV        a,[hl+b]        ;       a=[hl+b]
$DGL 0,4751
                MOV        x,a        ;       x=a
$DGL 0,4752
                INC        b        ;       b++
$DGL 0,4753
                push        bc        ;       push bc
$DGL 0,4754
                MOV        a,[hl+b]        ;       a=[hl+b]
$DGL 0,4755
                MOVW        pls_high,ax        ;       pls_high=ax
$DGL 0,4756
                MOVW        ax,pls_low        ;       bc=pls_low(ax)
                MOVW        bc,ax
$DGL 0,4757
                MOVW        ax,pls_high        ;       ax=pls_high
$DGL 0,4758
                call        !twobyte_subtract        ;       call !twobyte_subtract
$DGL 0,4759
                BNC        $?L542        ;     if_bit(cy)
$DGL 0,4760
                MOVW        ax,pls_high        ;       bc=pls_high(ax)
                MOVW        bc,ax
$DGL 0,4761
                MOVW        ax,pls_low        ;       ax=pls_low
$DGL 0,4762
                call        !twobyte_subtract        ;       call !twobyte_subtract
$DGL 0,4763
?L542:                                ;     endif
$DGL 0,4764
                CMPW        ax,#1200        ;     IF(ax<=#1200)
                BZ        $?L543
                BC        $?L543
                BR        ?L544
?L543:
$DGL 0,4765
                MOVW        ax,pls_low        ;       IF(pls_low>=#5000)(ax)
                CMPW        ax,#5000
                BNC        $?L545
                BR        ?L546
?L545:
$DGL 0,4766
                MOVW        ax,pls_high        ;         ax=pls_high
$DGL 0,4767
                MOVW        bc,#3556        ;         bc=#3556
$DGL 0,4768
                call        !twobyte_subtract        ;         call !twobyte_subtract
$DGL 0,4769
                pop        bc        ;         pop bc
$DGL 0,4770
                MOV        [hl+b],a        ;         [hl+b]=a
$DGL 0,4771
                DEC        b        ;         b--
$DGL 0,4772
                MOV        a,x        ;         [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4773
                INC        b        ;         b++
$DGL 0,4774
                INC        b        ;         b++
$DGL 0,4775
                INC        b        ;         b++
$DGL 0,4776
                push        bc        ;         push bc
$DGL 0,4777
                MOVW        ax,pls_low        ;         ax=pls_low
$DGL 0,4778
                MOVW        bc,#3556        ;         bc=#3556
$DGL 0,4779
                call        !twobyte_subtract        ;         call !twobyte_subtract
$DGL 0,4780
                pop        bc        ;         pop bc
$DGL 0,4781
                MOV        [hl+b],a        ;         [hl+b]=a
$DGL 0,4782
                DEC        b        ;         b--
$DGL 0,4783
                MOV        a,x        ;         [hl+b]=x(a)                  ;泿謽幚妿霂Y妳曽弾蹟?
                MOV        [hl+b],a
         
$DGL 0,4785
                MOV        a,counter        ;         a=counter
$DGL 0,4786
                DEC        a        ;         a--
$DGL 0,4787
                clr1        cy        ;         clr1 cy
$DGL 0,4788
                rol        a,1        ;         rol a,1
$DGL 0,4789
                and        a,#11111110b        ;         and a,#11111110b
$DGL 0,4790
                MOV        j,a        ;         j=a
$DGL 0,4791
                DEC        j        ;         j--
$DGL 0,4792
                MOV        a,i        ;         a=i
$DGL 0,4793
                clr1        cy        ;         clr1 cy  
$DGL 0,4794
                addc        a,#3        ;         addc a,#3
$DGL 0,4795
                clr1        cy        ;         clr1 cy
$DGL 0,4796
                rol        a,1        ;         rol a,1
$DGL 0,4797
                and        a,#11111110b        ;         and a,#11111110b
$DGL 0,4798
                DEC        a        ;         a--
$DGL 0,4799
                MOV        temp,a        ;         temp=a
$DGL 0,4800
RC_6code2:                        ;RC_6code2:
$DGL 0,4801
                MOVW        hl,#EEPROMBuf        ;           hl=#EEPROMBuf
$DGL 0,4802
                INCW        hl        ;           hl++
$DGL 0,4803
                INCW        hl        ;           hl++
$DGL 0,4804
                INCW        hl        ;           hl++
$DGL 0,4805
                clr1        cy        ;           clr1 cy
$DGL 0,4806
                MOV        a,l        ;           l+=j,cy(a)
                ADDC        a,j
                MOV        l,a
$DGL 0,4807
                MOV        a,h        ;           h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,4808
                MOV        a,[hl]        ;           a=[hl]
$DGL 0,4809
                MOV        [hl+4],a        ;           [hl+4]=a
$DGL 0,4810
                DEC        j        ;           j--
$DGL 0,4811
                MOV        a,temp        ;           a=temp
$DGL 0,4812
                cmp        a,j        ;           cmp a,j
$DGL 0,4813
                bc        $RC_6code2        ;           bc $RC_6code2
        
$DGL 0,4815
                MOVW        bc,#3556        ;           bc=#3556
$DGL 0,4816
                MOV        a,c        ;           [hl]=c(a)
                MOV        [hl],a
$DGL 0,4817
                INCW        hl        ;           hl++
$DGL 0,4818
                MOV        a,b        ;           [hl]=b(a)
                MOV        [hl],a
$DGL 0,4819
                INCW        hl        ;           hl++
$DGL 0,4820
                MOV        a,c        ;           [hl]=c(a)
                MOV        [hl],a
$DGL 0,4821
                INCW        hl        ;           hl++
$DGL 0,4822
                MOV        a,b        ;           [hl]=b(a)
                MOV        [hl],a
$DGL 0,4823
                MOV        a,counter        ;           a=counter
$DGL 0,4824
                INC        a        ;           a++
$DGL 0,4825
                INC        a        ;           a++
$DGL 0,4826
                MOV        counter,a        ;           counter=a
$DGL 0,4827
                ret                ;           ret
                BR        ?L547
$DGL 0,4828
?L546:                                ;       ELSE
$DGL 0,4829
                MOVW        ax,pls_low        ;         IF(pls_low>=#3200)(ax)
                CMPW        ax,#3200
                BNC        $?L548
                BR        ?L549
?L548:
$DGL 0,4830
                pop        bc        ;            pop bc
$DGL 0,4831
                DEC        b        ;            b--
$DGL 0,4832
                DEC        b        ;            b--
$DGL 0,4833
                DEC        b        ;            b--
$DGL 0,4834
                MOV        a,[hl+b]        ;            x=[hl+b](a)
                MOV        x,a
$DGL 0,4835
                INC        b        ;            b++
$DGL 0,4836
                MOV        a,[hl+b]        ;            a=[hl+b]
            
$DGL 0,4838
                push        bc        ;            push bc
$DGL 0,4839
                MOVW        bc,#3556        ;            bc=#3556
$DGL 0,4840
                call        !twobytes_add        ;            call !twobytes_add
$DGL 0,4841
                pop        bc        ;            pop bc
$DGL 0,4842
                MOV        [hl+b],a        ;            [hl+b]=a
$DGL 0,4843
                DEC        b        ;            b--
$DGL 0,4844
                MOV        a,x        ;            [hl+b]=x(a)
                MOV        [hl+b],a
            
$DGL 0,4846
                INC        b        ;            b++
$DGL 0,4847
                INC        b        ;            b++
$DGL 0,4848
                MOV        a,#0        ;            [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,4849
                INC        b        ;            b++
$DGL 0,4850
                MOV        a,#0        ;            [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,4851
                INC        b        ;            b++
$DGL 0,4852
                MOV        a,#0        ;            [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,4853
                INC        b        ;            b++
$DGL 0,4854
                MOV        a,#0        ;            [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,4855
                INC        b        ;            b++
$DGL 0,4856
                MOV        a,[hl+b]        ;            x=[hl+b](a)
                MOV        x,a
$DGL 0,4857
                INC        b        ;            b++
$DGL 0,4858
                MOV        a,[hl+b]        ;            a=[hl+b]
$DGL 0,4859
                push        bc        ;            push bc
$DGL 0,4860
                MOVW        bc,#3556        ;            bc=#3556
$DGL 0,4861
                call        !twobytes_add        ;            call !twobytes_add
$DGL 0,4862
                pop        bc        ;            pop bc
$DGL 0,4863
                MOV        [hl+b],a        ;            [hl+b]=a
$DGL 0,4864
                DEC        b        ;            b--
$DGL 0,4865
                MOV        a,x        ;            [hl+b]=x(a)            
                MOV        [hl+b],a
$DGL 0,4866
?L549:                                ;         ENDIF
$DGL 0,4867
?L547:                                ;       ENDIF  
                BR        ?L550
$DGL 0,4868
?L544:                                ;     ELSE
$DGL 0,4869
                MOVW        ax,pls_low        ;       IF(pls_low>=#5000)(ax)
                CMPW        ax,#5000
                BNC        $?L551
                BR        ?L552
?L551:
$DGL 0,4870
                pop        bc        ;           pop bc
$DGL 0,4871
                DEC        b        ;           b--
$DGL 0,4872
                DEC        b        ;           b--
$DGL 0,4873
                DEC        b        ;           b--
$DGL 0,4874
                MOV        a,[hl+b]        ;           x=[hl+b](a)
                MOV        x,a
$DGL 0,4875
                INC        b        ;           b++
$DGL 0,4876
                MOV        a,[hl+b]        ;           a=[hl+b]
$DGL 0,4877
                push        bc        ;           push bc                ;寧轀u弝
           
$DGL 0,4879
                MOVW        bc,#3556        ;           bc=#3556
$DGL 0,4880
                call        !twobytes_add        ;           call !twobytes_add
$DGL 0,4881
                pop        bc        ;           pop bc
$DGL 0,4882
                MOV        [hl+b],a        ;           [hl+b]=a
$DGL 0,4883
                DEC        b        ;           b--
$DGL 0,4884
                MOV        a,x        ;           [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4885
                INC        b        ;           b++
$DGL 0,4886
                INC        b        ;           b++
$DGL 0,4887
                INC        b        ;           b++
$DGL 0,4888
                MOVW        ax,#3556        ;           ax=#3556
$DGL 0,4889
                MOV        [hl+b],a        ;           [hl+b]=a
$DGL 0,4890
                DEC        b        ;           b--
$DGL 0,4891
                MOV        a,x        ;           [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4892
                INC        b        ;           b++
$DGL 0,4893
                INC        b        ;           b++
$DGL 0,4894
                MOV        a,[hl+b]        ;           x=[hl+b](a)
                MOV        x,a
$DGL 0,4895
                INC        b        ;           b++
$DGL 0,4896
                MOV        a,[hl+b]        ;           a=[hl+b]
$DGL 0,4897
                push        bc        ;           push bc
           
$DGL 0,4899
                MOVW        bc,#3556        ;           bc=#3556
$DGL 0,4900
                call        !twobyte_subtract        ;           call !twobyte_subtract
$DGL 0,4901
                pop        bc        ;           pop bc
$DGL 0,4902
                MOV        [hl+b],a        ;           [hl+b]=a
$DGL 0,4903
                DEC        b        ;           b--
$DGL 0,4904
                MOV        a,x        ;           [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4905
                ret                ;           ret
                BR        ?L553
$DGL 0,4906
?L552:                                ;       ELSE
$DGL 0,4907
                MOVW        ax,pls_high        ;         IF(pls_high>=#3200)(ax)
                CMPW        ax,#3200
                BNC        $?L554
                BR        ?L555
?L554:
$DGL 0,4908
                MOVW        ax,pls_high        ;           ax=pls_high
$DGL 0,4909
                MOVW        bc,#3556        ;           bc=#3556
$DGL 0,4910
                call        !twobyte_subtract        ;           call !twobyte_subtract
$DGL 0,4911
                pop        bc        ;           pop bc
$DGL 0,4912
                MOV        [hl+b],a        ;           [hl+b]=a
$DGL 0,4913
                DEC        b        ;           b--
$DGL 0,4914
                MOV        a,x        ;           [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4915
                INC        b        ;           b++
$DGL 0,4916
                INC        b        ;           b++
$DGL 0,4917
                INC        b        ;           b++
$DGL 0,4918
                MOVW        ax,#3556        ;           ax=#3556
$DGL 0,4919
                MOV        [hl+b],a        ;           [hl+b]=a
$DGL 0,4920
                DEC        b        ;           b--
$DGL 0,4921
                MOV        a,x        ;           [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4922
                INC        b        ;           b++
$DGL 0,4923
                INC        b        ;           b++
$DGL 0,4924
                MOV        a,[hl+b]        ;           x=[hl+b](a)
                MOV        x,a
$DGL 0,4925
                INC        b        ;           b++
$DGL 0,4926
                push        bc        ;           push bc                    ;寧轀u弝
$DGL 0,4927
                MOV        a,[hl+b]        ;           a=[hl+b]
           
$DGL 0,4929
                MOVW        bc,#3556        ;           bc=#3556
$DGL 0,4930
                call        !twobytes_add        ;           call !twobytes_add
$DGL 0,4931
                pop        bc        ;           pop bc
$DGL 0,4932
                MOV        [hl+b],a        ;           [hl+b]=a
$DGL 0,4933
                DEC        b        ;           b--
$DGL 0,4934
                MOV        a,x        ;           [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,4935
?L555:                                ;         ENDIF
$DGL 0,4936
?L553:                                ;       ENDIF  
$DGL 0,4937
?L550:                                ;     ENDIF
$DGL 0,4938
?L541:                                ;    ENDIF
$DGL 0,4939
?L539:                                ;   ENDIF
$DGL 0,4940
ret                                ;ret

$DGL 0,4942
deRC_5sub:                        ;deRC_5sub:
$DGL 0,4943
                MOVW        hl,#EEPROMBuf        ;   hl=#EEPROMBuf
$DGL 0,4944
                INCW        hl        ;   hl++
$DGL 0,4945
                INCW        hl        ;   hl++
$DGL 0,4946
                INCW        hl        ;   hl++
$DGL 0,4947
                MOV        i,#0        ;   i=#0
$DGL 0,4948
RC_5code:                        ;RC_5code:
$DGL 0,4949
                MOV        a,[hl]        ;      a=[hl]
$DGL 0,4950
                MOV        x,a        ;      x=a
$DGL 0,4951
                INCW        hl        ;      hl++
$DGL 0,4952
                MOV        a,[hl]        ;      a=[hl]
$DGL 0,4953
                MOVW        tempdata,ax        ;      tempdata=ax
$DGL 0,4954
                MOVW        ax,tempdata        ;      if((tempdata>=#3256)&&(tempdata<=#3856))(ax)
                CMPW        ax,#3256
                BC        $?L556
                MOVW        ax,tempdata
                CMPW        ax,#3856
                BZ        $$+4
                BNC        $?L556
$DGL 0,4955
                MOVW        bc,#3556        ;          bc=#3556
                BR        ?L557
$DGL 0,4956
?L556:                                ;      else
$DGL 0,4957
                MOVW        ax,tempdata        ;        if((tempdata>=#6712)&&(tempdata<=#7512))(ax)
                CMPW        ax,#6712
                BC        $?L558
                MOVW        ax,tempdata
                CMPW        ax,#7512
                BZ        $$+4
                BNC        $?L558
$DGL 0,4958
                MOVW        bc,#7112        ;          bc=#7112
$DGL 0,4959
                MOVW        ax,sum        ;          ax=sum
$DGL 0,4960
                call        !twobytes_add        ;          call !twobytes_add
$DGL 0,4961
                CMPW        ax,#10668        ;          if(ax>=#10668)
                BC        $?L559
$DGL 0,4962
                MOVW        bc,#3556        ;             bc=#3556
$DGL 0,4963
?L559:                                ;          endif
$DGL 0,4964
?L558:                                ;        endif
$DGL 0,4965
?L557:                                ;      endif
$DGL 0,4966
                MOVW        ax,sum        ;      ax=sum
$DGL 0,4967
                call        !twobytes_add        ;      call !twobytes_add
$DGL 0,4968
                MOVW        sum,ax        ;      sum=ax
$DGL 0,4969
                INCW        hl        ;      hl++
$DGL 0,4970
                INC        i        ;      i++
$DGL 0,4971
                MOVW        ax,sum        ;      ax=sum
$DGL 0,4972
                cmpw        ax,#10668        ;      cmpw ax,#10668
$DGL 0,4973
                bnz        $RC_5code        ;      bnz $RC_5code
      
$DGL 0,4975
                MOVW        hl,#EEPROMBuf        ;      hl=#EEPROMBuf
$DGL 0,4976
                INCW        hl        ;      hl++
$DGL 0,4977
                INCW        hl        ;      hl++
$DGL 0,4978
                INCW        hl        ;      hl++
$DGL 0,4979
                MOV        a,i        ;      a=i
$DGL 0,4980
                BT        a.0,$?L560        ;      IF_BIT(a.0)
                BR        ?L561
?L560:
$DGL 0,4981
                MOV        a,i        ;         a=i
$DGL 0,4982
                DEC        a        ;         a--
$DGL 0,4983
                clr1        cy        ;         clr1 cy
$DGL 0,4984
                rol        a,1        ;         rol a,1
$DGL 0,4985
                and        a,#11111110b        ;         and a,#11111110b
$DGL 0,4986
                MOV        b,a        ;         b=a
$DGL 0,4987
                MOV        a,[hl+b]        ;         a=[hl+b]
$DGL 0,4988
                MOV        x,a        ;         x=a
$DGL 0,4989
                INC        b        ;         b++
$DGL 0,4990
                MOV        a,[hl+b]        ;         a=[hl+b]
$DGL 0,4991
                MOVW        pls_high,ax        ;         pls_high=ax
$DGL 0,4992
                push        bc        ;         push bc
$DGL 0,4993
                INC        b        ;         b++
$DGL 0,4994
                MOV        a,[hl+b]        ;         a=[hl+b]
$DGL 0,4995
                MOV        x,a        ;         x=a
$DGL 0,4996
                INC        b        ;         b++
$DGL 0,4997
                MOV        a,[hl+b]        ;         a=[hl+b]
$DGL 0,4998
                MOVW        pls_low,ax        ;         pls_low=ax
$DGL 0,4999
                MOVW        ax,pls_high        ;         IF((pls_high>=#6712)&&(pls_high<=#7512))(ax)
                CMPW        ax,#6712
                BNC        $?L562
                BR        ?L564
?L562:
                MOVW        ax,pls_high
                CMPW        ax,#7512
                BZ        $?L563
                BC        $?L563
                BR        ?L564
?L563:
$DGL 0,5000
                MOVW        ax,pls_low        ;             IF((pls_low>=#3256)&&(pls_low<=#3856))(ax)
                CMPW        ax,#3256
                BNC        $?L565
                BR        ?L567
?L565:
                MOVW        ax,pls_low
                CMPW        ax,#3856
                BZ        $?L566
                BC        $?L566
                BR        ?L567
?L566:
$DGL 0,5001
                pop        bc        ;                pop bc
$DGL 0,5002
                MOVW        ax,#3556        ;                ax=#3556
$DGL 0,5003
                MOV        [hl+b],a        ;                [hl+b]=a
$DGL 0,5004
                DEC        b        ;                b--
$DGL 0,5005
                MOV        a,x        ;                [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,5006
                INC        b        ;                b++
$DGL 0,5007
                INC        b        ;                b++
$DGL 0,5008
                INC        b        ;                b++
$DGL 0,5009
                MOVW        ax,#3556        ;                ax=#3556
$DGL 0,5010
                MOV        [hl+b],a        ;                [hl+b]=a
$DGL 0,5011
                DEC        b        ;                b--
$DGL 0,5012
                MOV        a,x        ;                [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,5013
                INC        b        ;                b++
$DGL 0,5014
                INC        b        ;                b++
$DGL 0,5015
                INC        b        ;                b++
$DGL 0,5016
                MOVW        ax,#7112        ;                ax=#7112
$DGL 0,5017
                MOV        [hl+b],a        ;                [hl+b]=a
$DGL 0,5018
                DEC        b        ;                b--
$DGL 0,5019
                MOV        a,x        ;                [hl+b]=x(a)
                MOV        [hl+b],a
                BR        ?L568
$DGL 0,5020
?L567:                                ;             ELSE
$DGL 0,5021
                MOVW        ax,pls_low        ;                IF((pls_low>=#6712)&&(pls_low<=#7512))(ax)
                CMPW        ax,#6712
                BNC        $?L569
                BR        ?L571
?L569:
                MOVW        ax,pls_low
                CMPW        ax,#7512
                BZ        $?L570
                BC        $?L570
                BR        ?L571
?L570:
$DGL 0,5022
                pop        bc        ;                   pop bc
$DGL 0,5023
                MOVW        ax,#3556        ;                   ax=#3556
$DGL 0,5024
                MOV        [hl+b],a        ;                   [hl+b]=a
$DGL 0,5025
                DEC        b        ;                   b--
$DGL 0,5026
                MOV        a,x        ;                   [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,5027
                INC        b        ;                   b++
$DGL 0,5028
                INC        b        ;                   b++
$DGL 0,5029
                INC        b        ;                   b++
$DGL 0,5030
                MOVW        ax,#3556        ;                   ax=#3556
$DGL 0,5031
                MOV        [hl+b],a        ;                   [hl+b]=a
$DGL 0,5032
                DEC        b        ;                   b--
$DGL 0,5033
                MOV        a,x        ;                   [hl+b]=x(a)
                MOV        [hl+b],a
                  
$DGL 0,5035
                MOV        a,counter        ;                   a=counter
$DGL 0,5036
                DEC        a        ;                   a--
$DGL 0,5037
                clr1        cy        ;                   clr1 cy
$DGL 0,5038
                rol        a,1        ;                   rol a,1
$DGL 0,5039
                and        a,#11111110b        ;                   and a,#11111110b
$DGL 0,5040
                MOV        j,a        ;                   j=a
$DGL 0,5041
                DEC        j        ;                   j--
$DGL 0,5042
                MOV        a,i        ;                   a=i
$DGL 0,5043
                clr1        cy        ;                   clr1 cy
$DGL 0,5044
                rol        a,1        ;                   rol a,1
$DGL 0,5045
                and        a,#11111110b        ;                   and a,#11111110b
$DGL 0,5046
                DEC        a        ;                   a--
$DGL 0,5047
                MOV        temp,a        ;                   temp=a
$DGL 0,5048
RC_5code1:                        ;RC_5code1:
$DGL 0,5049
                MOVW        hl,#EEPROMBuf        ;           hl=#EEPROMBuf
$DGL 0,5050
                INCW        hl        ;           hl++
$DGL 0,5051
                INCW        hl        ;           hl++
$DGL 0,5052
                INCW        hl        ;           hl++
$DGL 0,5053
                clr1        cy        ;           clr1 cy
$DGL 0,5054
                MOV        a,l        ;           l+=j,cy(a)
                ADDC        a,j
                MOV        l,a
$DGL 0,5055
                MOV        a,h        ;           h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,5056
                MOV        a,[hl]        ;           a=[hl]
$DGL 0,5057
                MOV        [hl+4],a        ;           [hl+4]=a
$DGL 0,5058
                DEC        j        ;           j--
$DGL 0,5059
                MOV        a,temp        ;           a=temp
$DGL 0,5060
                cmp        a,j        ;           cmp a,j
$DGL 0,5061
                bc        $RC_5code1        ;           bc $RC_5code1
           
$DGL 0,5063
                MOVW        bc,#3556        ;           bc=#3556
$DGL 0,5064
                MOV        a,c        ;           [hl]=c(a)
                MOV        [hl],a
$DGL 0,5065
                INCW        hl        ;           hl++
$DGL 0,5066
                MOV        a,b        ;           [hl]=b(a)
                MOV        [hl],a
$DGL 0,5067
                INCW        hl        ;           hl++
$DGL 0,5068
                MOV        a,c        ;           [hl]=c(a)
                MOV        [hl],a
$DGL 0,5069
                INCW        hl        ;           hl++
$DGL 0,5070
                MOV        a,b        ;           [hl]=b(a)
                MOV        [hl],a
$DGL 0,5071
                MOV        a,counter        ;           a=counter
$DGL 0,5072
                INC        a        ;           a++
$DGL 0,5073
                INC        a        ;           a++
$DGL 0,5074
                MOV        counter,a        ;           counter=a
$DGL 0,5075
                ret                ;           ret
$DGL 0,5076
?L571:                                ;               ENDIF
$DGL 0,5077
?L568:                                ;             ENDIF      
                BR        ?L572
$DGL 0,5078
?L564:                                ;         ELSE
$DGL 0,5079
                pop        bc        ;           pop bc
$DGL 0,5080
                INC        b        ;           b++
$DGL 0,5081
                INC        b        ;           b++
$DGL 0,5082
                INC        b        ;           b++
$DGL 0,5083
                MOV        a,[hl+b]        ;           x=[hl+b](a)
                MOV        x,a
$DGL 0,5084
                INC        b        ;           b++
$DGL 0,5085
                push        bc        ;           push bc
$DGL 0,5086
                MOV        a,[hl+b]        ;           a=[hl+b]
$DGL 0,5087
                CMPW        ax,#3256        ;           IF((ax>=#3256)&&(ax<=#3856))
                BNC        $?L573
                BR        ?L575
?L573:
                CMPW        ax,#3856
                BZ        $?L574
                BC        $?L574
                BR        ?L575
?L574:
$DGL 0,5088
                pop        bc        ;              pop bc
$DGL 0,5089
                MOV        a,#0        ;              [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,5090
                push        bc        ;              push bc
$DGL 0,5091
                DEC        b        ;              b--
$DGL 0,5092
                MOV        a,#0        ;              [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,5093
                DEC        b        ;              b--
$DGL 0,5094
                MOV        a,#0        ;              [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,5095
                DEC        b        ;              b--
$DGL 0,5096
                MOV        a,#0        ;              [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,5097
                DEC        b        ;              b--
$DGL 0,5098
                MOVW        ax,#7112        ;              ax=#7112
$DGL 0,5099
                MOV        [hl+b],a        ;              [hl+b]=a
$DGL 0,5100
                DEC        b        ;              b--
$DGL 0,5101
                MOV        a,x        ;              [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,5102
                pop        bc        ;              pop bc
$DGL 0,5103
                INC        b        ;              b++
$DGL 0,5104
                INC        b        ;              b++
$DGL 0,5105
                MOVW        ax,#7112        ;              ax=#7112
$DGL 0,5106
                MOV        [hl+b],a        ;              [hl+b]=a
$DGL 0,5107
                DEC        b        ;              b--
$DGL 0,5108
                MOV        a,x        ;              [hl+b]=x(a)
                MOV        [hl+b],a
                BR        ?L576
$DGL 0,5109
?L575:                                ;           ELSE
$DGL 0,5110
                pop        bc        ;              pop bc
$DGL 0,5111
                MOVW        ax,#3556        ;              ax=#3556
$DGL 0,5112
                MOV        [hl+b],a        ;              [hl+b]=a
$DGL 0,5113
                DEC        b        ;              b--
$DGL 0,5114
                MOV        a,x        ;              [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,5115
                DEC        b        ;              b--
$DGL 0,5116
                MOVW        ax,#3556        ;              ax=#3556
$DGL 0,5117
                MOV        [hl+b],a        ;              [hl+b]=a
$DGL 0,5118
                DEC        b        ;              b--
$DGL 0,5119
                MOV        a,x        ;              [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,5120
                DEC        b        ;              b--
$DGL 0,5121
                MOVW        ax,#7112        ;              ax=#7112
$DGL 0,5122
                MOV        [hl+b],a        ;              [hl+b]=a
$DGL 0,5123
                DEC        b        ;              b--
$DGL 0,5124
                MOV        a,x        ;              [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,5125
?L576:                                ;           ENDIF  
$DGL 0,5126
?L572:                                ;         ENDIF     
                BR        ?L577
$DGL 0,5127
?L561:                                ;      ELSE
$DGL 0,5128
                BF        a.0,$?L578        ;         IF_BIT(!a.0)
                BR        ?L579
?L578:
$DGL 0,5129
                MOV        a,i        ;            a=i
$DGL 0,5130
                DEC        a        ;            a--
$DGL 0,5131
                clr1        cy        ;            clr1 cy
$DGL 0,5132
                rol        a,1        ;            rol a,1
$DGL 0,5133
                and        a,#11111110b        ;            and a,#11111110b
$DGL 0,5134
                MOV        b,a        ;            b=a
$DGL 0,5135
                MOV        a,[hl+b]        ;            a=[hl+b]
$DGL 0,5136
                MOV        x,a        ;            x=a
$DGL 0,5137
                INC        b        ;            b++
$DGL 0,5138
                MOV        a,[hl+b]        ;            a=[hl+b]
$DGL 0,5139
                MOVW        pls_low,ax        ;            pls_low=ax
$DGL 0,5140
                push        bc        ;            push bc
$DGL 0,5141
                INC        b        ;            b++
$DGL 0,5142
                MOV        a,[hl+b]        ;            a=[hl+b]
$DGL 0,5143
                MOV        x,a        ;            x=a
$DGL 0,5144
                INC        b        ;            b++
$DGL 0,5145
                MOV        a,[hl+b]        ;            a=[hl+b]
$DGL 0,5146
                MOVW        pls_high,ax        ;            pls_high=ax
$DGL 0,5147
                MOVW        ax,pls_low        ;            IF((pls_low>=#3256)&&(pls_low<=#3856))(ax)
                CMPW        ax,#3256
                BNC        $?L580
                BR        ?L582
?L580:
                MOVW        ax,pls_low
                CMPW        ax,#3856
                BZ        $?L581
                BC        $?L581
                BR        ?L582
?L581:
$DGL 0,5148
                pop        bc        ;               pop bc
$DGL 0,5149
                INC        b        ;               b++
$DGL 0,5150
                INC        b        ;               b++
$DGL 0,5151
                INC        b        ;               b++
$DGL 0,5152
                MOV        a,[hl+b]        ;               x=[hl+b](a)
                MOV        x,a
$DGL 0,5153
                INC        b        ;               b++
$DGL 0,5154
                push        bc        ;               push bc
$DGL 0,5155
                MOV        a,[hl+b]        ;               a=[hl+b]
$DGL 0,5156
                CMPW        ax,#6712        ;               IF((ax>=#6712)&&(ax<=#7512))
                BNC        $?L583
                BR        ?L585
?L583:
                CMPW        ax,#7512
                BZ        $?L584
                BC        $?L584
                BR        ?L585
?L584:
$DGL 0,5157
                pop        bc        ;                  pop bc
$DGL 0,5158
                MOVW        ax,#3556        ;                  ax=#3556
$DGL 0,5159
                MOV        [hl+b],a        ;                  [hl+b]=a
$DGL 0,5160
                DEC        b        ;                  b--
$DGL 0,5161
                MOV        a,x        ;                  [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,5162
                DEC        b        ;                  b--
$DGL 0,5163
                MOVW        ax,#3556        ;                  ax=#3556
$DGL 0,5164
                MOV        [hl+b],a        ;                  [hl+b]=a
$DGL 0,5165
                DEC        b        ;                  b--
$DGL 0,5166
                MOV        a,x        ;                  [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,5167
                DEC        b        ;                  b--
$DGL 0,5168
                MOVW        ax,#7112        ;                  ax=#7112
$DGL 0,5169
                MOV        [hl+b],a        ;                  [hl+b]=a
$DGL 0,5170
                DEC        b        ;                  b--
$DGL 0,5171
                MOV        a,x        ;                  [hl+b]=x(a)
                MOV        [hl+b],a
                BR        ?L586
$DGL 0,5172
?L585:                                ;               ELSE
$DGL 0,5173
                pop        bc        ;                  pop bc
$DGL 0,5174
                MOV        a,#0        ;                  [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,5175
                push        bc        ;                  push bc
$DGL 0,5176
                DEC        b        ;                  b--
$DGL 0,5177
                MOV        a,#0        ;                  [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,5178
                DEC        b        ;                  b--
$DGL 0,5179
                MOV        a,#0        ;                  [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,5180
                DEC        b        ;                  b--
$DGL 0,5181
                MOV        a,#0        ;                  [hl+b]=#0(a)
                MOV        [hl+b],a
$DGL 0,5182
                DEC        b        ;                  b--
$DGL 0,5183
                MOVW        ax,#7112        ;                  ax=#7112
$DGL 0,5184
                MOV        [hl+b],a        ;                  [hl+b]=a
$DGL 0,5185
                DEC        b        ;                  b--
$DGL 0,5186
                MOV        a,x        ;                  [hl+b]=x(a)
                MOV        [hl+b],a
                  
$DGL 0,5188
                pop        bc        ;                  pop bc
$DGL 0,5189
                INC        b        ;                  b++
$DGL 0,5190
                INC        b        ;                  b++
$DGL 0,5191
                MOVW        ax,#7112        ;                  ax=#7112
$DGL 0,5192
                MOV        [hl+b],a        ;                  [hl+b]=a
$DGL 0,5193
                DEC        b        ;                  b--
$DGL 0,5194
                MOV        a,x        ;                  [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,5195
?L586:                                ;               ENDIF  
                BR        ?L587
$DGL 0,5196
?L582:                                ;            ELSE
$DGL 0,5197
                MOVW        ax,pls_low        ;              IF((pls_low>=#6912)&&(pls_low<=#7512))(ax)
                CMPW        ax,#6912
                BNC        $?L588
                BR        ?L590
?L588:
                MOVW        ax,pls_low
                CMPW        ax,#7512
                BZ        $?L589
                BC        $?L589
                BR        ?L590
?L589:
$DGL 0,5198
                pop        bc        ;                 pop bc
$DGL 0,5199
                INC        b        ;                 b++
$DGL 0,5200
                MOV        a,[hl+b]        ;                 x=[hl+b](a)
                MOV        x,a
$DGL 0,5201
                INC        b        ;                 b++
$DGL 0,5202
                MOV        a,[hl+b]        ;                 a=[hl+b]
$DGL 0,5203
                CMPW        ax,#3256        ;                 IF((ax>=#3256)&&(ax<=#3856))
                BNC        $?L591
                BR        ?L593
?L591:
                CMPW        ax,#3856
                BZ        $?L592
                BC        $?L592
                BR        ?L593
?L592:
$DGL 0,5204
                MOVW        ax,#3556        ;                    ax=#3556
$DGL 0,5205
                MOV        [hl+b],a        ;                    [hl+b]=a
$DGL 0,5206
                push        bc        ;                    push bc
$DGL 0,5207
                DEC        b        ;                    b--
$DGL 0,5208
                MOV        a,x        ;                    [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,5209
                DEC        b        ;                    b--
$DGL 0,5210
                MOVW        ax,#3556        ;                    ax=#3556
$DGL 0,5211
                MOV        [hl+b],a        ;                    [hl+b]=a
$DGL 0,5212
                DEC        b        ;                    b--
$DGL 0,5213
                MOV        a,x        ;                    [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,5214
                pop        bc        ;                    pop bc
$DGL 0,5215
                INC        b        ;                    b++
$DGL 0,5216
                INC        b        ;                    b++
$DGL 0,5217
                MOVW        ax,#7112        ;                    ax=#7112
$DGL 0,5218
                MOV        [hl+b],a        ;                    [hl+b]=a
$DGL 0,5219
                DEC        b        ;                    b--
$DGL 0,5220
                MOV        a,x        ;                    [hl+b]=x(a)
                MOV        [hl+b],a
                BR        ?L594
$DGL 0,5221
?L593:                                ;                 ELSE
$DGL 0,5222
                CMPW        ax,#6912        ;                   IF((ax>=#6912)&&(ax<=#7512))
                BNC        $?L595
                BR        ?L597
?L595:
                CMPW        ax,#7512
                BZ        $?L596
                BC        $?L596
                BR        ?L597
?L596:
$DGL 0,5223
                MOVW        ax,#3556        ;                      ax=#3556
$DGL 0,5224
                MOV        [hl+b],a        ;                      [hl+b]=a
$DGL 0,5225
                DEC        b        ;                      b--
$DGL 0,5226
                MOV        a,x        ;                      [hl+b]=x(a)
                MOV        [hl+b],a
$DGL 0,5227
                DEC        b        ;                      b--
$DGL 0,5228
                MOVW        ax,#3556        ;                      ax=#3556
$DGL 0,5229
                MOV        [hl+b],a        ;                      [hl+b]=a
$DGL 0,5230
                DEC        b        ;                      b--
$DGL 0,5231
                MOV        a,x        ;                      [hl+b]=x(a)
                MOV        [hl+b],a
                     
$DGL 0,5233
                MOV        a,counter        ;                      a=counter
$DGL 0,5234
                DEC        a        ;                      a--
$DGL 0,5235
                clr1        cy        ;                      clr1 cy
$DGL 0,5236
                rol        a,1        ;                      rol a,1
$DGL 0,5237
                and        a,#11111110b        ;                      and a,#11111110b
$DGL 0,5238
                MOV        j,a        ;                      j=a
$DGL 0,5239
                DEC        j        ;                      j--
$DGL 0,5240
                MOV        a,i        ;                      a=i
$DGL 0,5241
                clr1        cy        ;                      clr1 cy
$DGL 0,5242
                rol        a,1        ;                      rol a,1
$DGL 0,5243
                and        a,#11111110b        ;                      and a,#11111110b
$DGL 0,5244
                DEC        a        ;                      a--
$DGL 0,5245
                MOV        temp,a        ;                      temp=a
$DGL 0,5246
RC_5code2:                        ;RC_5code2:
$DGL 0,5247
                MOVW        hl,#EEPROMBuf        ;           hl=#EEPROMBuf
$DGL 0,5248
                INCW        hl        ;           hl++
$DGL 0,5249
                INCW        hl        ;           hl++
$DGL 0,5250
                INCW        hl        ;           hl++
$DGL 0,5251
                clr1        cy        ;           clr1 cy
$DGL 0,5252
                MOV        a,l        ;           l+=j,cy(a)
                ADDC        a,j
                MOV        l,a
$DGL 0,5253
                MOV        a,h        ;           h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,5254
                MOV        a,[hl]        ;           a=[hl]
$DGL 0,5255
                MOV        [hl+4],a        ;           [hl+4]=a
$DGL 0,5256
                DEC        j        ;           j--
$DGL 0,5257
                MOV        a,temp        ;           a=temp
$DGL 0,5258
                cmp        a,j        ;           cmp a,j
$DGL 0,5259
                bc        $RC_5code2        ;           bc $RC_5code2
           
$DGL 0,5261
                MOVW        bc,#3556        ;           bc=#3556
$DGL 0,5262
                MOV        a,c        ;           [hl]=c(a)
                MOV        [hl],a
$DGL 0,5263
                INCW        hl        ;           hl++
$DGL 0,5264
                MOV        a,b        ;           [hl]=b(a)
                MOV        [hl],a
$DGL 0,5265
                INCW        hl        ;           hl++
$DGL 0,5266
                MOV        a,c        ;           [hl]=c(a)
                MOV        [hl],a
$DGL 0,5267
                INCW        hl        ;           hl++
$DGL 0,5268
                MOV        a,b        ;           [hl]=b(a)
                MOV        [hl],a
$DGL 0,5269
                MOV        a,counter        ;           a=counter
$DGL 0,5270
                INC        a        ;           a++
$DGL 0,5271
                INC        a        ;           a++
$DGL 0,5272
                MOV        counter,a        ;           counter=a
$DGL 0,5273
                ret                ;           ret
$DGL 0,5274
?L597:                                ;                   ENDIF
$DGL 0,5275
?L594:                                ;                 ENDIF
$DGL 0,5276
?L590:                                ;              ENDIF     
$DGL 0,5277
?L587:                                ;            ENDIF        
$DGL 0,5278
?L579:                                ;         ENDIF
$DGL 0,5279
?L577:                                ;      ENDIF         
$DGL 0,5280
ret                                ;ret

$DGL 0,5282
sub429:                                ;sub429:
$DGL 0,5283
                MOVW        HL,#EEPROMBuf        ;   HL=#EEPROMBuf
$DGL 0,5284
                INCW        hl        ;   hl++
$DGL 0,5285
                INCW        hl        ;   hl++
$DGL 0,5286
                INCW        hl        ;   hl++
$DGL 0,5287
                MOV        sametime,#0        ;   sametime=#0
$DGL 0,5288
                MOV        i,#0        ;   i=#0
$DGL 0,5289
sub_pro429:                        ;sub_pro429:
$DGL 0,5290
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,5291
                MOV        x,a        ;   x=a
$DGL 0,5292
                INCW        hl        ;   hl++
$DGL 0,5293
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,5294
                MOVW        tempdata,ax        ;   tempdata=ax
$DGL 0,5295
                MOVW        ax,tempdata        ;   if((tempdata>=#28000)&&(tempdata<=#30000))(ax)
                CMPW        ax,#28000
                BC        $?L598
                MOVW        ax,tempdata
                CMPW        ax,#30000
                BZ        $$+4
                BNC        $?L598
$DGL 0,5296
                INC        sametime        ;      sametime++
                BR        ?L599
$DGL 0,5297
?L598:                                ;   else
$DGL 0,5298
                MOVW        ax,tempdata        ;      if((tempdata>=#1050)&&(tempdata<=#1300))(ax)
                CMPW        ax,#1050
                BC        $?L600
                MOVW        ax,tempdata
                CMPW        ax,#1300
                BZ        $$+4
                BNC        $?L600
$DGL 0,5299
                INC        sametime        ;         sametime++
                BR        ?L601
$DGL 0,5300
?L600:                                ;      else
$DGL 0,5301
                MOVW        ax,tempdata        ;        if((tempdata>=#18500)&&(tempdata<=#20000))(ax)
                CMPW        ax,#18500
                BC        $?L602
                MOVW        ax,tempdata
                CMPW        ax,#20000
                BZ        $$+4
                BNC        $?L602
$DGL 0,5302
                INC        sametime        ;          sametime++
$DGL 0,5303
?L602:                                ;        endif
$DGL 0,5304
?L601:                                ;      endif
$DGL 0,5305
?L599:                                ;   endif
$DGL 0,5306
                INCW        hl        ;   hl++
$DGL 0,5307
                INC        i        ;   i++
$DGL 0,5308
                MOV        a,counter        ;   a=counter
$DGL 0,5309
                clr1        cy        ;   clr1 cy
$DGL 0,5310
                subc        a,#1        ;   subc a,#1
$DGL 0,5311
                MOV        temp,a        ;   temp=a
$DGL 0,5312
                cmp        a,i        ;   cmp a,i
$DGL 0,5313
                bnz        $sub_pro429        ;   bnz $sub_pro429
   
$DGL 0,5315
                MOV        a,temp        ;   a=temp
$DGL 0,5316
                clr1        cy        ;   clr1 cy
$DGL 0,5317
                subc        a,#8        ;   subc a,#8
$DGL 0,5318
                MOV        temp,a        ;   temp=a
   
$DGL 0,5320
                MOV        a,sametime        ;   a=sametime
$DGL 0,5321
                CMP        a,temp        ;   if(a>=temp)
                BC        $?L603
$DGL 0,5322
                set1        code429        ;      set1 code429
$DGL 0,5323
?L603:                                ;   endif
$DGL 0,5324
                MOV        sametime,#0        ;   sametime=#0
$DGL 0,5325
ret                                ;ret

$DGL 0,5327
desub429:                        ;desub429:
$DGL 0,5328
                MOVW        hl,#EEPROMBuf        ;   hl=#EEPROMBuf
$DGL 0,5329
                clr1        cy        ;   clr1 cy
$DGL 0,5330
                MOV        a,l        ;   l+=#9,cy(a)
                ADDC        a,#9
                MOV        l,a
$DGL 0,5331
                MOV        a,h        ;   h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,5332
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,5333
                MOV        x,a        ;   x=a
$DGL 0,5334
                INCW        hl        ;   hl++
$DGL 0,5335
                push        hl        ;   push hl
$DGL 0,5336
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,5337
                CMPW        ax,#18500        ;   if((ax>=#18500)&&(ax<=#20000))
                BC        $?L604
                CMPW        ax,#20000
                BZ        $$+4
                BNC        $?L604
$DGL 0,5338
                pop        hl        ;      pop hl
$DGL 0,5339
                MOVW        ax,#29200        ;      ax=#29200
$DGL 0,5340
                MOV        [hl],a        ;      [hl]=a
$DGL 0,5341
                DECW        hl        ;      hl--
$DGL 0,5342
                MOV        a,x        ;      [hl]=x(a)
                MOV        [hl],a
                BR        ?L605
$DGL 0,5343
?L604:                                ;   else
$DGL 0,5344
                CMPW        ax,#28000        ;      if((ax>=#28000)&&(ax<=#30000))
                BC        $?L606
                CMPW        ax,#30000
                BZ        $$+4
                BNC        $?L606
$DGL 0,5345
                pop        hl        ;         pop hl
$DGL 0,5346
                MOVW        ax,#19200        ;         ax=#19200
$DGL 0,5347
                MOV        [hl],a        ;         [hl]=a
$DGL 0,5348
                DECW        hl        ;         hl--
$DGL 0,5349
                MOV        a,x        ;         [hl]=x(a)
                MOV        [hl],a
$DGL 0,5350
?L606:                                ;       endif
$DGL 0,5351
?L605:                                ;   endif
$DGL 0,5352
ret                                ;ret
$DGL 0,5353
sub345:                                ;sub345:
$DGL 0,5354
                MOVW        HL,#EEPROMBuf        ;   HL=#EEPROMBuf
$DGL 0,5355
                INCW        hl        ;   hl++
$DGL 0,5356
                INCW        hl        ;   hl++
$DGL 0,5357
                INCW        hl        ;   hl++
$DGL 0,5358
                MOV        sametime,#0        ;   sametime=#0
$DGL 0,5359
                MOV        i,#0        ;   i=#0
$DGL 0,5360
sub_pro345:                        ;sub_pro345:
$DGL 0,5361
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,5362
                MOV        x,a        ;   x=a
$DGL 0,5363
                INCW        hl        ;   hl++
$DGL 0,5364
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,5365
                MOVW        tempdata,ax        ;   tempdata=ax
$DGL 0,5366
                MOVW        ax,tempdata        ;   if((tempdata>=#2100)&&(tempdata<=#2500))(ax)
                CMPW        ax,#2100
                BC        $?L607
                MOVW        ax,tempdata
                CMPW        ax,#2500
                BZ        $$+4
                BNC        $?L607
$DGL 0,5367
                INC        sametime        ;      sametime++
                BR        ?L608
$DGL 0,5368
?L607:                                ;   else
$DGL 0,5369
                MOVW        ax,tempdata        ;      if((tempdata>=#7800)&&(tempdata<=#8300))(ax)
                CMPW        ax,#7800
                BC        $?L609
                MOVW        ax,tempdata
                CMPW        ax,#8300
                BZ        $$+4
                BNC        $?L609
$DGL 0,5370
                INC        sametime        ;         sametime++
                BR        ?L610
$DGL 0,5371
?L609:                                ;      else
$DGL 0,5372
                MOVW        ax,tempdata        ;        if((tempdata>=#17500)&&(tempdata<=#19000))(ax)
                CMPW        ax,#17500
                BC        $?L611
                MOVW        ax,tempdata
                CMPW        ax,#19000
                BZ        $$+4
                BNC        $?L611
$DGL 0,5373
                INC        sametime        ;          sametime++
$DGL 0,5374
?L611:                                ;        endif
$DGL 0,5375
?L610:                                ;      endif
$DGL 0,5376
?L608:                                ;   endif
$DGL 0,5377
                INCW        hl        ;   hl++
$DGL 0,5378
                INC        i        ;   i++
$DGL 0,5379
                MOV        a,counter        ;   a=counter
$DGL 0,5380
                clr1        cy        ;   clr1 cy
$DGL 0,5381
                subc        a,#1        ;   subc a,#1
$DGL 0,5382
                MOV        temp,a        ;   temp=a
$DGL 0,5383
                cmp        a,i        ;   cmp a,i
$DGL 0,5384
                bnz        $sub_pro345        ;   bnz $sub_pro345
   
$DGL 0,5386
                MOV        a,temp        ;   a=temp
$DGL 0,5387
                clr1        cy        ;   clr1 cy
$DGL 0,5388
                subc        a,#8        ;   subc a,#8
$DGL 0,5389
                MOV        temp,a        ;   temp=a
   
$DGL 0,5391
                MOV        a,sametime        ;   a=sametime
$DGL 0,5392
                CMP        a,temp        ;   if(a>=temp)
                BC        $?L612
$DGL 0,5393
                set1        code345        ;      set1 code345
$DGL 0,5394
?L612:                                ;   endif
$DGL 0,5395
                MOV        sametime,#0        ;   sametime=#0
$DGL 0,5396
                ret                ;   ret
$DGL 0,5397
desub345:                        ;desub345:
$DGL 0,5398
                MOVW        hl,#EEPROMBuf        ;   hl=#EEPROMBuf
$DGL 0,5399
                clr1        cy        ;   clr1 cy
$DGL 0,5400
                MOV        a,l        ;   l+=#21,cy(a)
                ADDC        a,#21
                MOV        l,a
$DGL 0,5401
                MOV        a,h        ;   h+=#0,cy(a)
                ADDC        a,#0
                MOV        h,a
$DGL 0,5402
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,5403
                MOV        x,a        ;   x=a
$DGL 0,5404
                INCW        hl        ;   hl++
$DGL 0,5405
                push        hl        ;   push hl
$DGL 0,5406
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,5407
                CMPW        ax,#7800        ;   if((ax>=#7800)&&(ax<=#8200))
                BC        $?L613
                CMPW        ax,#8200
                BZ        $$+4
                BNC        $?L613
$DGL 0,5408
                pop        hl        ;      pop hl
$DGL 0,5409
                MOVW        ax,#18500        ;      ax=#18500
$DGL 0,5410
                MOV        [hl],a        ;      [hl]=a
$DGL 0,5411
                DECW        hl        ;      hl--
$DGL 0,5412
                MOV        a,x        ;      [hl]=x(a)
                MOV        [hl],a
                BR        ?L614
$DGL 0,5413
?L613:                                ;   else
$DGL 0,5414
                CMPW        ax,#17500        ;      if((ax>=#17500)&&(ax<=#19000))
                BC        $?L615
                CMPW        ax,#19000
                BZ        $$+4
                BNC        $?L615
$DGL 0,5415
                pop        hl        ;         pop hl
$DGL 0,5416
                MOVW        ax,#7900        ;         ax=#7900
$DGL 0,5417
                MOV        [hl],a        ;         [hl]=a
$DGL 0,5418
                DECW        hl        ;         hl--
$DGL 0,5419
                MOV        a,x        ;         [hl]=x(a)
                MOV        [hl],a
$DGL 0,5420
?L615:                                ;       endif
$DGL 0,5421
?L614:                                ;   endif
$DGL 0,5422
                ret                ;   ret
$DGL 0,5423
samestringsub:                        ;samestringsub:
$DGL 0,5424
                CMP        intervaloverflow1,#0        ;if(intervaloverflow1!=#0)
                BZ        $?L616
$DGL 0,5425
                CMP        intervaloverflow2,#0        ;  if(intervaloverflow2==#0)
                BNZ        $?L617
$DGL 0,5426
                MOV        a,counter        ;    a=counter
$DGL 0,5427
                clr1        cy        ;    clr1 cy
$DGL 0,5428
                ror        a,1        ;    ror a,1
$DGL 0,5429
                and        a,#01111111b        ;    and a,#01111111b
$DGL 0,5430
                CMP        a,conscounter1        ;    if(a==conscounter1)
                BNZ        $?L618
$DGL 0,5431
                MOVW        temp,#2        ;      temp=#2
$DGL 0,5432
?L618:                                ;    endif
                BR        ?L619
$DGL 0,5433
?L617:                                ;  else
$DGL 0,5434
                CMP        intervaloverflow2,#0        ;    if(intervaloverflow2!=#0)
                BZ        $?L620
$DGL 0,5435
                CMP        intervaloverflow3,#0        ;     if(intervaloverflow3==#0)
                BNZ        $?L621
$DGL 0,5436
                MOV        a,conscounter2        ;        a=conscounter2
$DGL 0,5437
                clr1        cy        ;        clr1 cy
$DGL 0,5438
                ror        a,1        ;        ror a,1
$DGL 0,5439
                and        a,#01111111b        ;        and a,#01111111b
$DGL 0,5440
                CMP        a,conscounter1        ;        if(a==conscounter1)
                BNZ        $?L622
$DGL 0,5441
                MOVW        temp,#3        ;           temp=#3
$DGL 0,5442
?L622:                                ;        endif
                BR        ?L623
$DGL 0,5443
?L621:                                ;     else
$DGL 0,5444
                CMP        intervaloverflow3,#0        ;       if(intervaloverflow3!=#0)
                BZ        $?L624
$DGL 0,5445
                MOV        a,conscounter1        ;        a=conscounter1
$DGL 0,5446
                clr1        cy        ;        clr1 cy
$DGL 0,5447
                rol        a,1        ;        rol a,1
$DGL 0,5448
                and        a,#11111110b        ;        and a,#11111110b
$DGL 0,5449
                MOV        c,a        ;        c=a
$DGL 0,5450
                push        bc        ;        push bc
$DGL 0,5451
                CMP        a,conscounter2        ;        if(a==conscounter2)
                BNZ        $?L625
$DGL 0,5452
                MOV        a,conscounter1        ;          x=conscounter1(a)
                MOV        x,a
$DGL 0,5453
                clr1        cy        ;          clr1 cy
$DGL 0,5454
                MOV        a,c        ;          a=c
$DGL 0,5455
                addc        a,x        ;          addc a,x
$DGL 0,5456
                CMP        a,conscounter3        ;          if(a==conscounter3)
                BNZ        $?L626
$DGL 0,5457
                MOVW        temp,#4        ;            temp=#4
$DGL 0,5458
?L626:                                ;          endif
$DGL 0,5459
?L625:                                ;        endif
$DGL 0,5460
                pop        bc        ;        pop bc
$DGL 0,5461
?L624:                                ;       endif
$DGL 0,5462
?L623:                                ;     endif
$DGL 0,5463
?L620:                                ;    endif
$DGL 0,5464
?L619:                                ;  endif
$DGL 0,5465
?L616:                                ;endif

$DGL 0,5467
                MOV        a,temp        ;if(temp==#2)(a)
                CMP        a,#2
                BNZ        $?L627
$DGL 0,5468
                clr1        samestring        ;   clr1 samestring
$DGL 0,5469
                MOV        a,counter        ;   a=counter
$DGL 0,5470
                DEC        a        ;   a--
$DGL 0,5471
                DEC        a        ;   a--
$DGL 0,5472
                clr1        cy        ;   clr1 cy
$DGL 0,5473
                ror        a,1        ;   ror a,1
$DGL 0,5474
                and        a,#01111111b        ;   and a,#01111111b
$DGL 0,5475
                clr1        cy        ;   clr1 cy
$DGL 0,5476
                ror        a,1        ;   ror a,1
$DGL 0,5477
                and        a,#01111111b        ;   and a,#01111111b
$DGL 0,5478
                INC        a        ;   a++
$DGL 0,5479
                MOV        b,a        ;   b=a
$DGL 0,5480
                MOVW        hl,#codeflowbyte        ;   hl=#codeflowbyte
$DGL 0,5481
                MOV        sametime,#0        ;   sametime=#0
$DGL 0,5482
                MOV        i,#0        ;   i=#0
$DGL 0,5483
samestring_pro1:                ;samestring_pro1:
$DGL 0,5484
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,5485
                CMP        a,[hl+b]        ;   if(a==[hl+b])
                BNZ        $?L628
$DGL 0,5486
                INC        sametime        ;      sametime++
$DGL 0,5487
?L628:                                ;   endif
$DGL 0,5488
                INCW        hl        ;   hl++
$DGL 0,5489
                INC        i        ;   i++
$DGL 0,5490
                MOV        a,b        ;   a=b
$DGL 0,5491
                DEC        a        ;   a--
$DGL 0,5492
                cmp        a,i        ;   cmp a,i
$DGL 0,5493
                bnz        $samestring_pro1        ;   bnz $samestring_pro1
   
$DGL 0,5495
                MOV        a,b        ;   a=b
$DGL 0,5496
                DEC        a        ;   a--
$DGL 0,5497
                CMP        a,sametime        ;   if(a==sametime)
                BNZ        $?L629
$DGL 0,5498
                set1        samestring        ;       set1 samestring
$DGL 0,5499
                MOVW        temp,#0        ;       temp=#0
$DGL 0,5500
?L629:                                ;   endif
$DGL 0,5501
?L627:                                ;endif

$DGL 0,5503
                MOV        a,temp        ;if(temp==#3)(a)
                CMP        a,#3
                BNZ        $?L630
$DGL 0,5504
                MOV        a,conscounter1        ;   a=conscounter1
$DGL 0,5505
                clr1        cy        ;   clr1 cy
$DGL 0,5506
                ror        a,1        ;   ror a,1
$DGL 0,5507
                and        a,#01111111b        ;   and a,#01111111b
$DGL 0,5508
                MOV        b,a        ;   b=a
$DGL 0,5509
                MOV        j,a        ;   j=a
$DGL 0,5510
                MOVW        hl,#codeflowbyte        ;   hl=#codeflowbyte
$DGL 0,5511
                MOV        sametime,#0        ;   sametime=#0
$DGL 0,5512
                MOV        i,#0        ;   i=#0
$DGL 0,5513
samestring_pro2:                ;samestring_pro2:
$DGL 0,5514
                MOV        a,j        ;   b=j(a)
                MOV        b,a
$DGL 0,5515
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,5516
                CMP        a,[hl+b]        ;   if(a==[hl+b])
                BNZ        $?L631
$DGL 0,5517
                push        bc        ;      push bc
$DGL 0,5518
                MOV        a,b        ;      a=b
$DGL 0,5519
                clr1        cy        ;      clr1 cy
$DGL 0,5520
                rol        a,1        ;      rol a,1
$DGL 0,5521
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,5522
                MOV        b,a        ;      b=a
$DGL 0,5523
                MOV        a,[hl]        ;      a=[hl]
$DGL 0,5524
                CMP        a,[hl+b]        ;      if(a==[hl+b])
                BNZ        $?L632
$DGL 0,5525
                INC        sametime        ;        sametime++
$DGL 0,5526
?L632:                                ;      endif
$DGL 0,5527
                pop        bc        ;      pop bc
$DGL 0,5528
?L631:                                ;   endif
$DGL 0,5529
                INCW        hl        ;   hl++
$DGL 0,5530
                INC        i        ;   i++
$DGL 0,5531
                MOV        a,j        ;   a=j
$DGL 0,5532
                DEC        a        ;   a--
$DGL 0,5533
                cmp        a,i        ;   cmp a,i
$DGL 0,5534
                bnz        $samestring_pro2        ;   bnz $samestring_pro2
   
$DGL 0,5536
                MOV        a,b        ;   a=b
$DGL 0,5537
                DEC        a        ;   a--
$DGL 0,5538
                CMP        a,sametime        ;   if(a==sametime)
                BNZ        $?L633
$DGL 0,5539
                set1        samestring        ;       set1 samestring
$DGL 0,5540
                MOVW        temp,#0        ;       temp=#0
$DGL 0,5541
?L633:                                ;   endif
$DGL 0,5542
?L630:                                ;endif

$DGL 0,5544
                MOV        a,temp        ;if(temp==#4)(a)
                CMP        a,#4
                BNZ        $?L634
$DGL 0,5545
                MOV        a,conscounter1        ;   a=conscounter1
$DGL 0,5546
                clr1        cy        ;   clr1 cy
$DGL 0,5547
                ror        a,1        ;   ror a,1
$DGL 0,5548
                and        a,#01111111b        ;   and a,#01111111b
$DGL 0,5549
                MOV        b,a        ;   b=a
$DGL 0,5550
                MOV        j,a        ;   j=a
$DGL 0,5551
                MOVW        hl,#codeflowbyte        ;   hl=#codeflowbyte
$DGL 0,5552
                MOV        sametime,#0        ;   sametime=#0
$DGL 0,5553
                MOV        i,#0        ;   i=#0
$DGL 0,5554
samestring_pro3:                ;samestring_pro3:
$DGL 0,5555
                MOV        a,j        ;   b=j(a)
                MOV        b,a
$DGL 0,5556
                MOV        a,[hl]        ;   a=[hl]
$DGL 0,5557
                CMP        a,[hl+b]        ;   if(a==[hl+b])
                BNZ        $?L635
$DGL 0,5558
                MOV        a,b        ;      a=b
$DGL 0,5559
                MOV        temp,a        ;      temp=a
$DGL 0,5560
                clr1        cy        ;      clr1 cy
$DGL 0,5561
                rol        a,1        ;      rol a,1
$DGL 0,5562
                and        a,#11111110b        ;      and a,#11111110b
$DGL 0,5563
                MOV        b,a        ;      b=a
$DGL 0,5564
                MOV        a,[hl]        ;      a=[hl]
$DGL 0,5565
                CMP        a,[hl+b]        ;      if(a==[hl+b])
                BNZ        $?L636
$DGL 0,5566
                MOV        a,temp        ;        x=temp(a)
                MOV        x,a
$DGL 0,5567
                MOV        a,b        ;        a=b
$DGL 0,5568
                clr1        cy        ;        clr1 cy
$DGL 0,5569
                addc        a,x        ;        addc a,x
$DGL 0,5570
                MOV        b,a        ;        b=a
$DGL 0,5571
                MOV        a,[hl]        ;        a=[hl]
$DGL 0,5572
                CMP        a,[hl+b]        ;        if(a==[hl+b])
                BNZ        $?L637
$DGL 0,5573
                INC        sametime        ;          sametime++
$DGL 0,5574
?L637:                                ;        endif
$DGL 0,5575
?L636:                                ;      endif
$DGL 0,5576
?L635:                                ;   endif
$DGL 0,5577
                INCW        hl        ;   hl++
$DGL 0,5578
                INC        i        ;   i++
$DGL 0,5579
                MOV        a,j        ;   a=j
$DGL 0,5580
                DEC        a        ;   a--
$DGL 0,5581
                cmp        a,i        ;   cmp a,i
$DGL 0,5582
                bnz        $samestring_pro3        ;   bnz $samestring_pro3
   
$DGL 0,5584
                MOV        a,j        ;   a=j
$DGL 0,5585
                DEC        a        ;   a--
$DGL 0,5586
                CMP        a,sametime        ;   if(a==sametime)
                BNZ        $?L638
$DGL 0,5587
                set1        samestring        ;       set1 samestring
$DGL 0,5588
                MOVW        temp,#0        ;       temp=#0
$DGL 0,5589
?L638:                                ;   endif
$DGL 0,5590
?L634:                                ;endif
$DGL 0,5591
                MOVW        temp,#0        ;   temp=#0
$DGL 0,5592
                MOV        i,#0        ;   i=#0
$DGL 0,5593
                MOV        j,#0        ;   j=#0
$DGL 0,5594
                MOV        sametime,#0        ;   sametime=#0
$DGL 0,5595
ret                                ;ret
$DGL 0,5596
END                                ;END

yihui184

不知道说什么～

xiaoqingy

29楼的代码简直是天书啊

marshallemon

白菜价