
Ex2_TFT43_KeyDTMF.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .data         00000038  00800100  00001b90  00001c24  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  1 .text         00001b90  00000000  00000000  00000094  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  2 .bss          0000000e  00800138  00800138  00001c5c  2**0
                  ALLOC
  3 .debug_aranges 00000020  00000000  00000000  00001c5c  2**0
                  CONTENTS, READONLY, DEBUGGING
  4 .debug_pubnames 000002e6  00000000  00000000  00001c7c  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_info   0000162b  00000000  00000000  00001f62  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_abbrev 0000025c  00000000  00000000  0000358d  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_line   00001475  00000000  00000000  000037e9  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_frame  00000270  00000000  00000000  00004c60  2**2
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_str    000003f9  00000000  00000000  00004ed0  2**0
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_loc    0000113d  00000000  00000000  000052c9  2**0
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_ranges 000000c0  00000000  00000000  00006406  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
       0:	0c 94 46 00 	jmp	0x8c	; 0x8c <__ctors_end>
       4:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
       8:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
       c:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      10:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      14:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      18:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      1c:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      20:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      24:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      28:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      2c:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      30:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      34:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      38:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      3c:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      40:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      44:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      48:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      4c:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      50:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      54:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      58:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      5c:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      60:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      64:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      68:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      6c:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      70:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      74:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      78:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      7c:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      80:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      84:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>
      88:	0c 94 66 00 	jmp	0xcc	; 0xcc <__bad_interrupt>

0000008c <__ctors_end>:
      8c:	11 24       	eor	r1, r1
      8e:	1f be       	out	0x3f, r1	; 63
      90:	cf ef       	ldi	r28, 0xFF	; 255
      92:	d0 e1       	ldi	r29, 0x10	; 16
      94:	de bf       	out	0x3e, r29	; 62
      96:	cd bf       	out	0x3d, r28	; 61

00000098 <__do_copy_data>:
      98:	11 e0       	ldi	r17, 0x01	; 1
      9a:	a0 e0       	ldi	r26, 0x00	; 0
      9c:	b1 e0       	ldi	r27, 0x01	; 1
      9e:	e0 e9       	ldi	r30, 0x90	; 144
      a0:	fb e1       	ldi	r31, 0x1B	; 27
      a2:	00 e0       	ldi	r16, 0x00	; 0
      a4:	0b bf       	out	0x3b, r16	; 59
      a6:	02 c0       	rjmp	.+4      	; 0xac <__do_copy_data+0x14>
      a8:	07 90       	elpm	r0, Z+
      aa:	0d 92       	st	X+, r0
      ac:	a8 33       	cpi	r26, 0x38	; 56
      ae:	b1 07       	cpc	r27, r17
      b0:	d9 f7       	brne	.-10     	; 0xa8 <__do_copy_data+0x10>
      b2:	1b be       	out	0x3b, r1	; 59

000000b4 <__do_clear_bss>:
      b4:	11 e0       	ldi	r17, 0x01	; 1
      b6:	a8 e3       	ldi	r26, 0x38	; 56
      b8:	b1 e0       	ldi	r27, 0x01	; 1
      ba:	01 c0       	rjmp	.+2      	; 0xbe <.do_clear_bss_start>

000000bc <.do_clear_bss_loop>:
      bc:	1d 92       	st	X+, r1

000000be <.do_clear_bss_start>:
      be:	a6 34       	cpi	r26, 0x46	; 70
      c0:	b1 07       	cpc	r27, r17
      c2:	e1 f7       	brne	.-8      	; 0xbc <.do_clear_bss_loop>
      c4:	0e 94 b9 0d 	call	0x1b72	; 0x1b72 <main>
      c8:	0c 94 c6 0d 	jmp	0x1b8c	; 0x1b8c <_exit>

000000cc <__bad_interrupt>:
      cc:	0c 94 00 00 	jmp	0	; 0x0 <__vectors>

000000d0 <delay_ms>:
    milliseconds can be achieved.
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
      d0:	20 ea       	ldi	r18, 0xA0	; 160
      d2:	3f e0       	ldi	r19, 0x0F	; 15
      d4:	04 c0       	rjmp	.+8      	; 0xde <delay_ms+0xe>
      d6:	f9 01       	movw	r30, r18
      d8:	31 97       	sbiw	r30, 0x01	; 1
      da:	f1 f7       	brne	.-4      	; 0xd8 <delay_ms+0x8>
 ++                                                ++
 +++++++++++++++++++++++++++++++++++++++++++++++++++*/

 void delay_ms(unsigned int cnt)
  {
    for(;cnt>0;cnt--)
      dc:	01 97       	sbiw	r24, 0x01	; 1
      de:	00 97       	sbiw	r24, 0x00	; 0
      e0:	d1 f7       	brne	.-12     	; 0xd6 <delay_ms+0x6>
       _delay_ms(1);
  }
      e2:	08 95       	ret

000000e4 <init_port>:
  +++++++++++++++++++++++++++++++++++++++++++++++++++*/

 void init_port(void)
  {

   DDRB  = 0x5E     ;        //Set PB1[MOSI],PB2[SCK],PB3[CS],PB4[PD#],PB6[SD_CS] = Output ; PB0[MISO],PB5(INT)=Input
      e4:	8e e5       	ldi	r24, 0x5E	; 94
      e6:	87 bb       	out	0x17, r24	; 23
   
   //------ Set Value Default Port ------ 
         
   PORTB = 0x7B     ;       //Set Default Port PB0(MISO),PB5(INT) = 1(Pull Up) ,PB4(PD)=1(Disable Power down),PB3(CS)=1, 
      e8:	8b e7       	ldi	r24, 0x7B	; 123
      ea:	88 bb       	out	0x18, r24	; 24
                            //                 PB2(SCK)=0,PB1(MOSI)=1 ,PB6(SD_CS) =1  

  }
      ec:	08 95       	ret

000000ee <spi_sdo_hi>:

//++++++++++++++++ Data MOSI [PB1] ++++++++++++++++++

void spi_sdo_hi(void)
 {
   sbi(PORTB,1) ;        //PB1 =1
      ee:	c1 9a       	sbi	0x18, 1	; 24
 }
      f0:	08 95       	ret

000000f2 <spi_sdo_lo>:

void spi_sdo_lo(void)
 {
  cbi(PORTB,1)  ;        //PB1 =0
      f2:	c1 98       	cbi	0x18, 1	; 24
 }
      f4:	08 95       	ret

000000f6 <spi_sck_hi>:

//+++++++++++++++++ SCK [PB2] ++++++++++++++++++++++

void spi_sck_hi(void)
 {
   sbi(PORTB,2) ;        //PB2 =1
      f6:	c2 9a       	sbi	0x18, 2	; 24
 }
      f8:	08 95       	ret

000000fa <spi_sck_lo>:

void spi_sck_lo(void) 
 {
   cbi(PORTB,2) ;        //PB2 =0 (Ideal)
      fa:	c2 98       	cbi	0x18, 2	; 24
 }
      fc:	08 95       	ret

000000fe <spi_cs_hi>:

//+++++++++++++++++ CS [PB3] ++++++++++++++++++++++

 void spi_cs_hi(void)
 {
   sbi(PORTB,3)  ;       //PB3 =1
      fe:	c3 9a       	sbi	0x18, 3	; 24
 }
     100:	08 95       	ret

00000102 <spi_cs_lo>:

void spi_cs_lo(void)
 {
   cbi(PORTB,3) ;        //PB3 =0 (Active)
     102:	c3 98       	cbi	0x18, 3	; 24
 }
     104:	08 95       	ret

00000106 <spi_rw>:
 ++                                                                                   ++
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/


unsigned char spi_rw(unsigned char Db)              
{
     106:	28 2f       	mov	r18, r24
     108:	90 e0       	ldi	r25, 0x00	; 0
     10a:	80 e0       	ldi	r24, 0x00	; 0

     for(bt=0;bt<8;bt++)                       //Loop read/write 8 bit
      {      
      //--------- Write Data(PB1) ---------

      if((Db & 0x80)== 0x80)
     10c:	27 ff       	sbrs	r18, 7
     10e:	02 c0       	rjmp	.+4      	; 0x114 <spi_rw+0xe>

//++++++++++++++++ Data MOSI [PB1] ++++++++++++++++++

void spi_sdo_hi(void)
 {
   sbi(PORTB,1) ;        //PB1 =1
     110:	c1 9a       	sbi	0x18, 1	; 24
     112:	01 c0       	rjmp	.+2      	; 0x116 <spi_rw+0x10>
 }

void spi_sdo_lo(void)
 {
  cbi(PORTB,1)  ;        //PB1 =0
     114:	c1 98       	cbi	0x18, 1	; 24

//+++++++++++++++++ SCK [PB2] ++++++++++++++++++++++

void spi_sck_hi(void)
 {
   sbi(PORTB,2) ;        //PB2 =1
     116:	c2 9a       	sbi	0x18, 2	; 24
      spi_sck_hi()                         ;    //Start Clock  High (active rise edge) 
   
       
        //---------- Read Data(PB0) -------
     
      result <<= 1                         ;    //Shift data read to MSB bit
     118:	88 0f       	add	r24, r24
                      
      if((PINB & 0x01)== 0x01)                  //If SDI = "1"                  
     11a:	b0 99       	sbic	0x16, 0	; 22
        {
          result |= 0x01                   ;    //Keep Result of Read-data                             
     11c:	81 60       	ori	r24, 0x01	; 1
   sbi(PORTB,2) ;        //PB2 =1
 }

void spi_sck_lo(void) 
 {
   cbi(PORTB,2) ;        //PB2 =0 (Ideal)
     11e:	c2 98       	cbi	0x18, 2	; 24

unsigned char spi_rw(unsigned char Db)              
{
  unsigned char bt,result=0;                   

     for(bt=0;bt<8;bt++)                       //Loop read/write 8 bit
     120:	9f 5f       	subi	r25, 0xFF	; 255
     122:	98 30       	cpi	r25, 0x08	; 8
     124:	11 f0       	breq	.+4      	; 0x12a <spi_rw+0x24>
      if((PINB & 0x01)== 0x01)                  //If SDI = "1"                  
        {
          result |= 0x01                   ;    //Keep Result of Read-data                             
        }

      Db  <<= 1                            ;    //Shift Next Bit Data           
     126:	22 0f       	add	r18, r18
     128:	f1 cf       	rjmp	.-30     	; 0x10c <spi_rw+0x6>
      spi_sck_lo()                         ;    //Clock low

    }

     return result                         ;
}
     12a:	08 95       	ret

0000012c <FT800_PD_hi>:
  ++                                                                         ++
  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

void FT800_PD_hi(void)
{
   sbi(PORTB,4)       ;   //PB4=1:Disable Power-Down FT800
     12c:	c4 9a       	sbi	0x18, 4	; 24
}
     12e:	08 95       	ret

00000130 <FT800_PD_lo>:


void FT800_PD_lo(void)
{
    cbi(PORTB,4)       ;   //PB4=0:Enable Power-Down FT800
     130:	c4 98       	cbi	0x18, 4	; 24
}
     132:	08 95       	ret

00000134 <FT800memWrite8>:

//++++++++++++++ Function-Write Address Register,Ram-DL,Ram-CMD + Data 8 bit ++++++++++++++++


void FT800memWrite8(unsigned long addr, unsigned char data8)
{
     134:	df 92       	push	r13
     136:	ef 92       	push	r14
     138:	ff 92       	push	r15
     13a:	0f 93       	push	r16
     13c:	1f 93       	push	r17
     13e:	7b 01       	movw	r14, r22
     140:	8c 01       	movw	r16, r24
     142:	d4 2e       	mov	r13, r20
   sbi(PORTB,3)  ;       //PB3 =1
 }

void spi_cs_lo(void)
 {
   cbi(PORTB,3) ;        //PB3 =0 (Active)
     144:	c3 98       	cbi	0x18, 3	; 24

void FT800memWrite8(unsigned long addr, unsigned char data8)
{
  spi_cs_lo()                     ; // Set CS# low

  spi_rw(((addr>>16)|MEM_WRITE))  ; // Send Memory Write plus high address byte
     146:	c8 01       	movw	r24, r16
     148:	aa 27       	eor	r26, r26
     14a:	bb 27       	eor	r27, r27
     14c:	80 68       	ori	r24, 0x80	; 128
     14e:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(addr>>8)                 ; // Send middle address byte
     152:	bb 27       	eor	r27, r27
     154:	a1 2f       	mov	r26, r17
     156:	90 2f       	mov	r25, r16
     158:	8f 2d       	mov	r24, r15
     15a:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(addr)                    ; // Send low address byte
     15e:	8e 2d       	mov	r24, r14
     160:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>

  spi_rw(data8)                   ; // Send data byte
     164:	8d 2d       	mov	r24, r13
     166:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>

//+++++++++++++++++ CS [PB3] ++++++++++++++++++++++

 void spi_cs_hi(void)
 {
   sbi(PORTB,3)  ;       //PB3 =1
     16a:	c3 9a       	sbi	0x18, 3	; 24
  spi_rw(addr)                    ; // Send low address byte

  spi_rw(data8)                   ; // Send data byte

  spi_cs_hi()                     ; // Set CS# high
}
     16c:	1f 91       	pop	r17
     16e:	0f 91       	pop	r16
     170:	ff 90       	pop	r15
     172:	ef 90       	pop	r14
     174:	df 90       	pop	r13
     176:	08 95       	ret

00000178 <FT800memWrite16>:


//++++++++++++++ Function-Write Address Register,Ram-DL,Ram-CMD + Data 16 bit++++++++++++++++

void FT800memWrite16(unsigned long addr, unsigned int data16)
{
     178:	cf 92       	push	r12
     17a:	df 92       	push	r13
     17c:	ef 92       	push	r14
     17e:	ff 92       	push	r15
     180:	0f 93       	push	r16
     182:	1f 93       	push	r17
     184:	7b 01       	movw	r14, r22
     186:	8c 01       	movw	r16, r24
     188:	d4 2e       	mov	r13, r20
     18a:	c5 2e       	mov	r12, r21
   sbi(PORTB,3)  ;       //PB3 =1
 }

void spi_cs_lo(void)
 {
   cbi(PORTB,3) ;        //PB3 =0 (Active)
     18c:	c3 98       	cbi	0x18, 3	; 24
void FT800memWrite16(unsigned long addr, unsigned int data16)
{

  spi_cs_lo()                     ;   // Set CS# low

  spi_rw(((addr>>16)|MEM_WRITE))  ;   // Send Memory Write plus high address byte
     18e:	aa 27       	eor	r26, r26
     190:	bb 27       	eor	r27, r27
     192:	80 68       	ori	r24, 0x80	; 128
     194:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(addr>>8)                 ;   // Send middle address byte
     198:	bb 27       	eor	r27, r27
     19a:	a1 2f       	mov	r26, r17
     19c:	90 2f       	mov	r25, r16
     19e:	8f 2d       	mov	r24, r15
     1a0:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(addr)                    ;   // Send low address byte
     1a4:	8e 2d       	mov	r24, r14
     1a6:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>

  spi_rw(data16)                  ;   // Send data low byte
     1aa:	8d 2d       	mov	r24, r13
     1ac:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(data16>>8)               ;   // Send data high byte
     1b0:	8c 2d       	mov	r24, r12
     1b2:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>

//+++++++++++++++++ CS [PB3] ++++++++++++++++++++++

 void spi_cs_hi(void)
 {
   sbi(PORTB,3)  ;       //PB3 =1
     1b6:	c3 9a       	sbi	0x18, 3	; 24
  spi_rw(data16)                  ;   // Send data low byte
  spi_rw(data16>>8)               ;   // Send data high byte
  
  spi_cs_hi()                     ;   // Set CS# high

}
     1b8:	1f 91       	pop	r17
     1ba:	0f 91       	pop	r16
     1bc:	ff 90       	pop	r15
     1be:	ef 90       	pop	r14
     1c0:	df 90       	pop	r13
     1c2:	cf 90       	pop	r12
     1c4:	08 95       	ret

000001c6 <FT800memWrite32>:

//++++++++++++ Function-Write Address Register,Ram-DL,Ram-CMD + Data 32 bit +++++++++++++++

void FT800memWrite32(unsigned long addr, unsigned long data32)
{
     1c6:	af 92       	push	r10
     1c8:	bf 92       	push	r11
     1ca:	cf 92       	push	r12
     1cc:	df 92       	push	r13
     1ce:	ef 92       	push	r14
     1d0:	ff 92       	push	r15
     1d2:	0f 93       	push	r16
     1d4:	1f 93       	push	r17
     1d6:	7b 01       	movw	r14, r22
     1d8:	8c 01       	movw	r16, r24
     1da:	59 01       	movw	r10, r18
     1dc:	6a 01       	movw	r12, r20
   sbi(PORTB,3)  ;       //PB3 =1
 }

void spi_cs_lo(void)
 {
   cbi(PORTB,3) ;        //PB3 =0 (Active)
     1de:	c3 98       	cbi	0x18, 3	; 24

void FT800memWrite32(unsigned long addr, unsigned long data32)
{
  spi_cs_lo()                     ;   // Set CS# low

  spi_rw(((addr>>16)|MEM_WRITE))  ;   // Send Memory Write plus high address byte
     1e0:	aa 27       	eor	r26, r26
     1e2:	bb 27       	eor	r27, r27
     1e4:	80 68       	ori	r24, 0x80	; 128
     1e6:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(addr>>8)                 ;   // Send middle address byte
     1ea:	bb 27       	eor	r27, r27
     1ec:	a1 2f       	mov	r26, r17
     1ee:	90 2f       	mov	r25, r16
     1f0:	8f 2d       	mov	r24, r15
     1f2:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(addr)                    ;   // Send low address byte
     1f6:	8e 2d       	mov	r24, r14
     1f8:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>

  spi_rw(data32)                  ;   // Send data low byte
     1fc:	8a 2d       	mov	r24, r10
     1fe:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(data32>>8)               ;   
     202:	bb 27       	eor	r27, r27
     204:	ad 2d       	mov	r26, r13
     206:	9c 2d       	mov	r25, r12
     208:	8b 2d       	mov	r24, r11
     20a:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(data32>>16)              ;   
     20e:	c6 01       	movw	r24, r12
     210:	aa 27       	eor	r26, r26
     212:	bb 27       	eor	r27, r27
     214:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(data32>>24)              ;   // Send data high byte
     218:	ad 2c       	mov	r10, r13
     21a:	bb 24       	eor	r11, r11
     21c:	cc 24       	eor	r12, r12
     21e:	dd 24       	eor	r13, r13
     220:	8a 2d       	mov	r24, r10
     222:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>

//+++++++++++++++++ CS [PB3] ++++++++++++++++++++++

 void spi_cs_hi(void)
 {
   sbi(PORTB,3)  ;       //PB3 =1
     226:	c3 9a       	sbi	0x18, 3	; 24
  spi_rw(data32>>16)              ;   
  spi_rw(data32>>24)              ;   // Send data high byte
  
  spi_cs_hi()                     ;   // Set CS# high

}
     228:	1f 91       	pop	r17
     22a:	0f 91       	pop	r16
     22c:	ff 90       	pop	r15
     22e:	ef 90       	pop	r14
     230:	df 90       	pop	r13
     232:	cf 90       	pop	r12
     234:	bf 90       	pop	r11
     236:	af 90       	pop	r10
     238:	08 95       	ret

0000023a <FT800memWriteStr>:
  ++                                                                        ++
  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

                                                          
void FT800memWriteStr(unsigned long addr,char *str)
{
     23a:	cf 92       	push	r12
     23c:	df 92       	push	r13
     23e:	ef 92       	push	r14
     240:	ff 92       	push	r15
     242:	0f 93       	push	r16
     244:	1f 93       	push	r17
     246:	cf 93       	push	r28
     248:	df 93       	push	r29
     24a:	7b 01       	movw	r14, r22
     24c:	8c 01       	movw	r16, r24
     24e:	d4 2e       	mov	r13, r20
     250:	c5 2e       	mov	r12, r21
  unsigned int i ;
  
  num_cha = 0                     ;
     252:	10 92 41 01 	sts	0x0141, r1
   sbi(PORTB,3)  ;       //PB3 =1
 }

void spi_cs_lo(void)
 {
   cbi(PORTB,3) ;        //PB3 =0 (Active)
     256:	c3 98       	cbi	0x18, 3	; 24
  unsigned int i ;
  
  num_cha = 0                     ;
  spi_cs_lo()                     ;   // Set CS# low

  spi_rw(((addr>>16)|MEM_WRITE))  ;   // Send Memory Write plus high address byte
     258:	aa 27       	eor	r26, r26
     25a:	bb 27       	eor	r27, r27
     25c:	80 68       	ori	r24, 0x80	; 128
     25e:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(addr>>8)                 ;   // Send middle address byte
     262:	bb 27       	eor	r27, r27
     264:	a1 2f       	mov	r26, r17
     266:	90 2f       	mov	r25, r16
     268:	8f 2d       	mov	r24, r15
     26a:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(addr)                    ;   // Send low address byte
     26e:	8e 2d       	mov	r24, r14
     270:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
     274:	2d 2d       	mov	r18, r13
     276:	3c 2d       	mov	r19, r12
     278:	c9 01       	movw	r24, r18
     27a:	ec 01       	movw	r28, r24
     27c:	07 c0       	rjmp	.+14     	; 0x28c <FT800memWriteStr+0x52>


 for (i=0; str[i] != '\0'; i++)       //Check End String In C
  {                 
     spi_rw(str[i])               ;
     27e:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
     num_cha +=  1                ;
     282:	80 91 41 01 	lds	r24, 0x0141
     286:	8f 5f       	subi	r24, 0xFF	; 255
     288:	80 93 41 01 	sts	0x0141, r24
  spi_rw(((addr>>16)|MEM_WRITE))  ;   // Send Memory Write plus high address byte
  spi_rw(addr>>8)                 ;   // Send middle address byte
  spi_rw(addr)                    ;   // Send low address byte


 for (i=0; str[i] != '\0'; i++)       //Check End String In C
     28c:	89 91       	ld	r24, Y+
     28e:	88 23       	and	r24, r24
     290:	b1 f7       	brne	.-20     	; 0x27e <FT800memWriteStr+0x44>
  {                 
     spi_rw(str[i])               ;
     num_cha +=  1                ;
  }

  spi_rw(0)                       ;   //Sent End Write String Sent 0
     292:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>

  num_cha = num_cha+1             ;
     296:	80 91 41 01 	lds	r24, 0x0141
     29a:	8f 5f       	subi	r24, 0xFF	; 255
     29c:	80 93 41 01 	sts	0x0141, r24

//+++++++++++++++++ CS [PB3] ++++++++++++++++++++++

 void spi_cs_hi(void)
 {
   sbi(PORTB,3)  ;       //PB3 =1
     2a0:	c3 9a       	sbi	0x18, 3	; 24

  num_cha = num_cha+1             ;

  spi_cs_hi()                     ;   // Set CS# high

}
     2a2:	df 91       	pop	r29
     2a4:	cf 91       	pop	r28
     2a6:	1f 91       	pop	r17
     2a8:	0f 91       	pop	r16
     2aa:	ff 90       	pop	r15
     2ac:	ef 90       	pop	r14
     2ae:	df 90       	pop	r13
     2b0:	cf 90       	pop	r12
     2b2:	08 95       	ret

000002b4 <FT800_HostCmdWrite>:
   sbi(PORTB,3)  ;       //PB3 =1
 }

void spi_cs_lo(void)
 {
   cbi(PORTB,3) ;        //PB3 =0 (Active)
     2b4:	c3 98       	cbi	0x18, 3	; 24

void FT800_HostCmdWrite(unsigned char Command)
{
  spi_cs_lo()            ;  // Set CS# low

  spi_rw(Command)        ;  // Send command
     2b6:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(0x00)           ;  // Commands consist of two more zero bytes
     2ba:	80 e0       	ldi	r24, 0x00	; 0
     2bc:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(0x00)           ;  // Send last zero byte
     2c0:	80 e0       	ldi	r24, 0x00	; 0
     2c2:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>

//+++++++++++++++++ CS [PB3] ++++++++++++++++++++++

 void spi_cs_hi(void)
 {
   sbi(PORTB,3)  ;       //PB3 =1
     2c6:	c3 9a       	sbi	0x18, 3	; 24
  spi_rw(Command)        ;  // Send command
  spi_rw(0x00)           ;  // Commands consist of two more zero bytes
  spi_rw(0x00)           ;  // Send last zero byte

  spi_cs_hi()            ;  // Set CS# high
}
     2c8:	08 95       	ret

000002ca <FT800memRead8>:


//++++++++++++++++++ Function-Read data Memory 8 bit +++++++++++++++++++++++

unsigned char FT800memRead8(unsigned long addr)
{
     2ca:	ef 92       	push	r14
     2cc:	ff 92       	push	r15
     2ce:	0f 93       	push	r16
     2d0:	1f 93       	push	r17
     2d2:	7b 01       	movw	r14, r22
     2d4:	8c 01       	movw	r16, r24
   sbi(PORTB,3)  ;       //PB3 =1
 }

void spi_cs_lo(void)
 {
   cbi(PORTB,3) ;        //PB3 =0 (Active)
     2d6:	c3 98       	cbi	0x18, 3	; 24
{
  unsigned char data8 ;

  spi_cs_lo()                     ; // Set CS# low

  spi_rw(((addr>>16)&MEM_READ))   ; // Send Memory Write plus high address byte
     2d8:	c8 01       	movw	r24, r16
     2da:	aa 27       	eor	r26, r26
     2dc:	bb 27       	eor	r27, r27
     2de:	8f 73       	andi	r24, 0x3F	; 63
     2e0:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(addr>>8)                 ; // Send middle address byte
     2e4:	bb 27       	eor	r27, r27
     2e6:	a1 2f       	mov	r26, r17
     2e8:	90 2f       	mov	r25, r16
     2ea:	8f 2d       	mov	r24, r15
     2ec:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(addr)                    ; // Send low address byte
     2f0:	8e 2d       	mov	r24, r14
     2f2:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(ZERO)                    ; // Send dummy byte
     2f6:	80 e0       	ldi	r24, 0x00	; 0
     2f8:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  data8 = spi_rw(ZERO)            ; // Read data byte
     2fc:	80 e0       	ldi	r24, 0x00	; 0
     2fe:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>

//+++++++++++++++++ CS [PB3] ++++++++++++++++++++++

 void spi_cs_hi(void)
 {
   sbi(PORTB,3)  ;       //PB3 =1
     302:	c3 9a       	sbi	0x18, 3	; 24
  spi_cs_hi()                     ; // Set CS# high

  return data8                    ; // Return byte read


}
     304:	1f 91       	pop	r17
     306:	0f 91       	pop	r16
     308:	ff 90       	pop	r15
     30a:	ef 90       	pop	r14
     30c:	08 95       	ret

0000030e <FT800memRead16>:


//++++++++++++++++++++ Function-Read data Memory 16 bit ++++++++++++++++++++

unsigned int FT800memRead16(unsigned long addr)
{
     30e:	ef 92       	push	r14
     310:	ff 92       	push	r15
     312:	0f 93       	push	r16
     314:	1f 93       	push	r17
     316:	7b 01       	movw	r14, r22
     318:	8c 01       	movw	r16, r24
   sbi(PORTB,3)  ;       //PB3 =1
 }

void spi_cs_lo(void)
 {
   cbi(PORTB,3) ;        //PB3 =0 (Active)
     31a:	c3 98       	cbi	0x18, 3	; 24
{
  unsigned int data16,dat;

  spi_cs_lo()                                  ; // Set CS# low

  spi_rw(((addr>>16)&MEM_READ))                ; // Send Memory Write plus high address byte
     31c:	aa 27       	eor	r26, r26
     31e:	bb 27       	eor	r27, r27
     320:	8f 73       	andi	r24, 0x3F	; 63
     322:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(addr>>8)                              ; // Send middle address byte
     326:	bb 27       	eor	r27, r27
     328:	a1 2f       	mov	r26, r17
     32a:	90 2f       	mov	r25, r16
     32c:	8f 2d       	mov	r24, r15
     32e:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(addr)                                 ; // Send low address byte
     332:	8e 2d       	mov	r24, r14
     334:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(ZERO)                                 ; // Send dummy byte
     338:	80 e0       	ldi	r24, 0x00	; 0
     33a:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>

  data16 = spi_rw(ZERO)                        ; // Read low byte
     33e:	80 e0       	ldi	r24, 0x00	; 0
     340:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
     344:	08 2f       	mov	r16, r24
     346:	10 e0       	ldi	r17, 0x00	; 0
  dat    = spi_rw(ZERO)                        ; // Read high byte
     348:	80 e0       	ldi	r24, 0x00	; 0
     34a:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>

//+++++++++++++++++ CS [PB3] ++++++++++++++++++++++

 void spi_cs_hi(void)
 {
   sbi(PORTB,3)  ;       //PB3 =1
     34e:	c3 9a       	sbi	0x18, 3	; 24
     350:	38 2f       	mov	r19, r24
     352:	20 e0       	ldi	r18, 0x00	; 0
     354:	20 2b       	or	r18, r16
     356:	31 2b       	or	r19, r17
  data16 = (dat << 8)| data16                  ; 
 
  spi_cs_hi()                                  ; // Set CS# high
    
  return data16;                                 // Return integer read
}
     358:	c9 01       	movw	r24, r18
     35a:	1f 91       	pop	r17
     35c:	0f 91       	pop	r16
     35e:	ff 90       	pop	r15
     360:	ef 90       	pop	r14
     362:	08 95       	ret

00000364 <FT800memRead32>:


//+++++++++++++++++ Function-Read data Memory 32 bit +++++++++++++++++++++

unsigned long FT800memRead32(unsigned long addr)
{
     364:	6f 92       	push	r6
     366:	7f 92       	push	r7
     368:	8f 92       	push	r8
     36a:	9f 92       	push	r9
     36c:	af 92       	push	r10
     36e:	bf 92       	push	r11
     370:	cf 92       	push	r12
     372:	df 92       	push	r13
     374:	ef 92       	push	r14
     376:	ff 92       	push	r15
     378:	0f 93       	push	r16
     37a:	1f 93       	push	r17
     37c:	7b 01       	movw	r14, r22
     37e:	8c 01       	movw	r16, r24
   sbi(PORTB,3)  ;       //PB3 =1
 }

void spi_cs_lo(void)
 {
   cbi(PORTB,3) ;        //PB3 =0 (Active)
     380:	c3 98       	cbi	0x18, 3	; 24
{
  unsigned long data32,dat;

  spi_cs_lo()                                  ; // Set CS# low

  spi_rw(((addr>>16)&MEM_READ))                ; // Send Memory Write plus high address byte
     382:	c8 01       	movw	r24, r16
     384:	aa 27       	eor	r26, r26
     386:	bb 27       	eor	r27, r27
     388:	8f 73       	andi	r24, 0x3F	; 63
     38a:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(addr>>8)                              ; // Send middle address byte
     38e:	bb 27       	eor	r27, r27
     390:	a1 2f       	mov	r26, r17
     392:	90 2f       	mov	r25, r16
     394:	8f 2d       	mov	r24, r15
     396:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(addr)                                 ; // Send low address byte
     39a:	8e 2d       	mov	r24, r14
     39c:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(ZERO)                                 ; // Send dummy byte
     3a0:	80 e0       	ldi	r24, 0x00	; 0
     3a2:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>


  data32 = spi_rw(ZERO)                        ; // Read low byte
     3a6:	80 e0       	ldi	r24, 0x00	; 0
     3a8:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
     3ac:	68 2e       	mov	r6, r24
     3ae:	77 24       	eor	r7, r7
     3b0:	88 24       	eor	r8, r8
     3b2:	99 24       	eor	r9, r9
  dat    = spi_rw(ZERO)                        ; 
     3b4:	80 e0       	ldi	r24, 0x00	; 0
     3b6:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
     3ba:	e8 2e       	mov	r14, r24
  data32 = (dat<<8)| data32                    ;
  dat    = spi_rw(ZERO)                        ; 
     3bc:	80 e0       	ldi	r24, 0x00	; 0
     3be:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
     3c2:	a8 2e       	mov	r10, r24
  data32 = (dat<<16)| data32                   ;
  dat    = spi_rw(ZERO)                        ; // Read high byte 
     3c4:	80 e0       	ldi	r24, 0x00	; 0
     3c6:	0e 94 83 00 	call	0x106	; 0x106 <spi_rw>
  spi_rw(ZERO)                                 ; // Send dummy byte


  data32 = spi_rw(ZERO)                        ; // Read low byte
  dat    = spi_rw(ZERO)                        ; 
  data32 = (dat<<8)| data32                    ;
     3ca:	ff 24       	eor	r15, r15
     3cc:	00 e0       	ldi	r16, 0x00	; 0
     3ce:	10 e0       	ldi	r17, 0x00	; 0
     3d0:	10 2f       	mov	r17, r16
     3d2:	0f 2d       	mov	r16, r15
     3d4:	fe 2c       	mov	r15, r14
     3d6:	ee 24       	eor	r14, r14
     3d8:	bb 24       	eor	r11, r11
     3da:	cc 24       	eor	r12, r12
     3dc:	dd 24       	eor	r13, r13
     3de:	65 01       	movw	r12, r10
     3e0:	bb 24       	eor	r11, r11
     3e2:	aa 24       	eor	r10, r10
     3e4:	ea 28       	or	r14, r10
     3e6:	fb 28       	or	r15, r11
     3e8:	0c 29       	or	r16, r12
     3ea:	1d 29       	or	r17, r13
  dat    = spi_rw(ZERO)                        ; 
  data32 = (dat<<16)| data32                   ;
     3ec:	e6 28       	or	r14, r6
     3ee:	f7 28       	or	r15, r7
     3f0:	08 29       	or	r16, r8
     3f2:	19 29       	or	r17, r9

//+++++++++++++++++ CS [PB3] ++++++++++++++++++++++

 void spi_cs_hi(void)
 {
   sbi(PORTB,3)  ;       //PB3 =1
     3f4:	c3 9a       	sbi	0x18, 3	; 24
     3f6:	90 e0       	ldi	r25, 0x00	; 0
     3f8:	a0 e0       	ldi	r26, 0x00	; 0
     3fa:	b0 e0       	ldi	r27, 0x00	; 0
     3fc:	b8 2f       	mov	r27, r24
     3fe:	aa 27       	eor	r26, r26
     400:	99 27       	eor	r25, r25
     402:	88 27       	eor	r24, r24
     404:	e8 2a       	or	r14, r24
     406:	f9 2a       	or	r15, r25
     408:	0a 2b       	or	r16, r26
     40a:	1b 2b       	or	r17, r27
  data32 = (dat<<24)| data32                   ;

  spi_cs_hi()                                  ; // Set CS# high
    
  return data32                                ; // Return integer read
}
     40c:	b7 01       	movw	r22, r14
     40e:	c8 01       	movw	r24, r16
     410:	1f 91       	pop	r17
     412:	0f 91       	pop	r16
     414:	ff 90       	pop	r15
     416:	ef 90       	pop	r14
     418:	df 90       	pop	r13
     41a:	cf 90       	pop	r12
     41c:	bf 90       	pop	r11
     41e:	af 90       	pop	r10
     420:	9f 90       	pop	r9
     422:	8f 90       	pop	r8
     424:	7f 90       	pop	r7
     426:	6f 90       	pop	r6
     428:	08 95       	ret

0000042a <Start_CMDOffset>:

 {
  //------------Determine Pointer Offset for Ram_CMD Address---------------
    do
     {
       cmdBufferRd = FT800memRead16(REG_CMD_READ)      ;   //***Read Reg.the graphics processor read pointer
     42a:	64 ee       	ldi	r22, 0xE4	; 228
     42c:	74 e2       	ldi	r23, 0x24	; 36
     42e:	80 e1       	ldi	r24, 0x10	; 16
     430:	90 e0       	ldi	r25, 0x00	; 0
     432:	0e 94 87 01 	call	0x30e	; 0x30e <FT800memRead16>
     436:	90 93 3d 01 	sts	0x013D, r25
     43a:	80 93 3c 01 	sts	0x013C, r24
       cmdBufferWr = FT800memRead16(REG_CMD_WRITE)     ;   //***Read Reg.the graphics processor write pointer
     43e:	68 ee       	ldi	r22, 0xE8	; 232
     440:	74 e2       	ldi	r23, 0x24	; 36
     442:	80 e1       	ldi	r24, 0x10	; 16
     444:	90 e0       	ldi	r25, 0x00	; 0
     446:	0e 94 87 01 	call	0x30e	; 0x30e <FT800memRead16>
     44a:	9c 01       	movw	r18, r24
     44c:	90 93 3f 01 	sts	0x013F, r25
     450:	80 93 3e 01 	sts	0x013E, r24
  
     }while(cmdBufferWr != cmdBufferRd)                ;   //Wait until the two registers match
     454:	80 91 3c 01 	lds	r24, 0x013C
     458:	90 91 3d 01 	lds	r25, 0x013D
     45c:	28 17       	cp	r18, r24
     45e:	39 07       	cpc	r19, r25
     460:	21 f7       	brne	.-56     	; 0x42a <Start_CMDOffset>
  
      cmdOffset = cmdBufferWr                          ;   //The new starting point the first location after the last command
     462:	30 93 3b 01 	sts	0x013B, r19
     466:	20 93 3a 01 	sts	0x013A, r18

 }
     46a:	08 95       	ret

0000046c <incCMDOffset>:

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     46c:	9c 01       	movw	r18, r24
     46e:	26 0f       	add	r18, r22
     470:	31 1d       	adc	r19, r1

    if(newOffset > 4095)                        //If new offset past boundary...
     472:	80 e1       	ldi	r24, 0x10	; 16
     474:	20 30       	cpi	r18, 0x00	; 0
     476:	38 07       	cpc	r19, r24
     478:	10 f0       	brcs	.+4      	; 0x47e <incCMDOffset+0x12>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     47a:	20 50       	subi	r18, 0x00	; 0
     47c:	30 41       	sbci	r19, 0x10	; 16
    }

    return newOffset;                           //Return new offset
}
     47e:	c9 01       	movw	r24, r18
     480:	08 95       	ret

00000482 <End_incCMDOffset>:

unsigned int End_incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
  unsigned int newOffset                   ;  //used to hold new offset

   newOffset = currentOffset + commandSize ;  //Calculate new offset
     482:	9c 01       	movw	r18, r24
     484:	26 0f       	add	r18, r22
     486:	31 1d       	adc	r19, r1

   if(newOffset > 4095)                       //If new offset past boundary...
     488:	80 e1       	ldi	r24, 0x10	; 16
     48a:	20 30       	cpi	r18, 0x00	; 0
     48c:	38 07       	cpc	r19, r24
     48e:	10 f0       	brcs	.+4      	; 0x494 <End_incCMDOffset+0x12>
    {
        newOffset = (newOffset - 4096)     ;  //... roll over pointer
     490:	20 50       	subi	r18, 0x00	; 0
     492:	30 41       	sbci	r19, 0x10	; 16
    }
   

  //increment the length and align it by 4 bytes//

   newOffset = (newOffset+3) & 4092        ;
     494:	2d 5f       	subi	r18, 0xFD	; 253
     496:	3f 4f       	sbci	r19, 0xFF	; 255
     498:	2c 7f       	andi	r18, 0xFC	; 252
     49a:	3f 70       	andi	r19, 0x0F	; 15

   return newOffset;                      //Return new offset
}
     49c:	c9 01       	movw	r24, r18
     49e:	08 95       	ret

000004a0 <Touch_Detect>:

 char Touch_Detect(void)
  {
    unsigned int td  ;

    td = FT800memRead16(REG_TOUCH_RAW_XY)  ;   //***Read Reg.Toucu Detect
     4a0:	68 e0       	ldi	r22, 0x08	; 8
     4a2:	75 e2       	ldi	r23, 0x25	; 37
     4a4:	80 e1       	ldi	r24, 0x10	; 16
     4a6:	90 e0       	ldi	r25, 0x00	; 0
     4a8:	0e 94 87 01 	call	0x30e	; 0x30e <FT800memRead16>
     4ac:	20 e0       	ldi	r18, 0x00	; 0
     4ae:	8f 5f       	subi	r24, 0xFF	; 255
     4b0:	9f 4f       	sbci	r25, 0xFF	; 255
     4b2:	09 f0       	breq	.+2      	; 0x4b6 <Touch_Detect+0x16>
     4b4:	21 e0       	ldi	r18, 0x01	; 1
   if(td != 0xFFFF)   
     return 1 ;       //Touch return 1
   else
     return 0 ;       //No Touch return 0
      
  }
     4b6:	82 2f       	mov	r24, r18
     4b8:	08 95       	ret

000004ba <Touch_Read_XY>:

void Touch_Read_XY(void)
 {
    unsigned long xy ;  

   xy = FT800memRead32(REG_TOUCH_SCREEN_XY)   ; //***Read Reg : Read Value Position XY Touch Screen
     4ba:	60 e1       	ldi	r22, 0x10	; 16
     4bc:	75 e2       	ldi	r23, 0x25	; 37
     4be:	80 e1       	ldi	r24, 0x10	; 16
     4c0:	90 e0       	ldi	r25, 0x00	; 0
     4c2:	0e 94 b2 01 	call	0x364	; 0x364 <FT800memRead32>

   tc_x = (xy >> 16) & 0x000001FF             ; //Mark X-Position 0-479 in Pixel
     4c6:	9c 01       	movw	r18, r24
     4c8:	44 27       	eor	r20, r20
     4ca:	55 27       	eor	r21, r21
     4cc:	31 70       	andi	r19, 0x01	; 1
     4ce:	30 93 43 01 	sts	0x0143, r19
     4d2:	20 93 42 01 	sts	0x0142, r18

   tc_y = xy & 0x1FF                          ; //Mark Y-Position 0-271 in Pixel 
     4d6:	71 70       	andi	r23, 0x01	; 1
     4d8:	70 93 45 01 	sts	0x0145, r23
     4dc:	60 93 44 01 	sts	0x0144, r22

 }
     4e0:	08 95       	ret

000004e2 <Sound_Effect>:
  ++                    00 : No Sound                                     ++                                                     
  ++                                                                      ++
  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

 void Sound_Effect(unsigned char vol,int midi,int effect)
  {
     4e2:	ff 92       	push	r15
     4e4:	0f 93       	push	r16
     4e6:	1f 93       	push	r17
     4e8:	28 2f       	mov	r18, r24
     4ea:	f6 2e       	mov	r15, r22
     4ec:	8a 01       	movw	r16, r20

    midi = midi << 8                                ;  //Set data Midi 8 bit High
    FT800memWrite8(REG_VOL_SOUND,vol)               ;  //***Write data to Reg : Turn synthesizer volume 0-0xFF   
     4ee:	60 e8       	ldi	r22, 0x80	; 128
     4f0:	74 e2       	ldi	r23, 0x24	; 36
     4f2:	80 e1       	ldi	r24, 0x10	; 16
     4f4:	90 e0       	ldi	r25, 0x00	; 0
     4f6:	42 2f       	mov	r20, r18
     4f8:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>
    FT800memWrite16(REG_SOUND,midi | effect)        ;  //***Write data to Reg : Select Sound Effect = Silence(No Sound) 
     4fc:	5f 2d       	mov	r21, r15
     4fe:	40 e0       	ldi	r20, 0x00	; 0
     500:	40 2b       	or	r20, r16
     502:	51 2b       	or	r21, r17
     504:	64 e8       	ldi	r22, 0x84	; 132
     506:	74 e2       	ldi	r23, 0x24	; 36
     508:	80 e1       	ldi	r24, 0x10	; 16
     50a:	90 e0       	ldi	r25, 0x00	; 0
     50c:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>
    FT800memWrite8(REG_PLAY,0x01)                   ;  //***Write data to Reg : Play Sound Effect
     510:	68 e8       	ldi	r22, 0x88	; 136
     512:	74 e2       	ldi	r23, 0x24	; 36
     514:	80 e1       	ldi	r24, 0x10	; 16
     516:	90 e0       	ldi	r25, 0x00	; 0
     518:	41 e0       	ldi	r20, 0x01	; 1
     51a:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>


  }
     51e:	1f 91       	pop	r17
     520:	0f 91       	pop	r16
     522:	ff 90       	pop	r15
     524:	08 95       	ret

00000526 <Start_CMDList>:
  ++           screen_color  : Color Background Screen                            ++
  ++                                                                              ++
  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
  
  void Start_CMDList(long screen_color)
   {
     526:	ef 92       	push	r14
     528:	ff 92       	push	r15
     52a:	0f 93       	push	r16
     52c:	1f 93       	push	r17
     52e:	7b 01       	movw	r14, r22
     530:	8c 01       	movw	r16, r24

    //-------------------- Start Display List ------------------------

     Start_CMDOffset()                                                  ; //Start Offset pointer for Ram-CMD
     532:	0e 94 15 02 	call	0x42a	; 0x42a <Start_CMDOffset>

     FT800memWrite32(RAM_CMD + cmdOffset,CMD_DLSTART)                   ; //*** Sent Co-CMD Start the display list                                                     
     536:	60 91 3a 01 	lds	r22, 0x013A
     53a:	70 91 3b 01 	lds	r23, 0x013B
     53e:	80 e0       	ldi	r24, 0x00	; 0
     540:	90 e0       	ldi	r25, 0x00	; 0
     542:	60 50       	subi	r22, 0x00	; 0
     544:	70 48       	sbci	r23, 0x80	; 128
     546:	8f 4e       	sbci	r24, 0xEF	; 239
     548:	9f 4f       	sbci	r25, 0xFF	; 255
     54a:	20 e0       	ldi	r18, 0x00	; 0
     54c:	3f ef       	ldi	r19, 0xFF	; 255
     54e:	4f ef       	ldi	r20, 0xFF	; 255
     550:	5f ef       	ldi	r21, 0xFF	; 255
     552:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     556:	80 91 3a 01 	lds	r24, 0x013A
     55a:	90 91 3b 01 	lds	r25, 0x013B
     55e:	bc 01       	movw	r22, r24
     560:	6c 5f       	subi	r22, 0xFC	; 252
     562:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     564:	20 e1       	ldi	r18, 0x10	; 16
     566:	60 30       	cpi	r22, 0x00	; 0
     568:	72 07       	cpc	r23, r18
     56a:	18 f0       	brcs	.+6      	; 0x572 <Start_CMDList+0x4c>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     56c:	bc 01       	movw	r22, r24
     56e:	6c 5f       	subi	r22, 0xFC	; 252
     570:	7f 40       	sbci	r23, 0x0F	; 15
    //-------------------- Start Display List ------------------------

     Start_CMDOffset()                                                  ; //Start Offset pointer for Ram-CMD

     FT800memWrite32(RAM_CMD + cmdOffset,CMD_DLSTART)                   ; //*** Sent Co-CMD Start the display list                                                     
     cmdOffset = incCMDOffset(cmdOffset,4)                              ; //Update Offset pointer Ram-CMD 4 byte for Next CMD     
     572:	70 93 3b 01 	sts	0x013B, r23
     576:	60 93 3a 01 	sts	0x013A, r22
    
     FT800memWrite32(RAM_CMD + cmdOffset,(DL_CLEAR_RGB | screen_color)) ; //*** Sent DL-CMD Clear color BackGround and Set Color BackGround                  
     57a:	80 e0       	ldi	r24, 0x00	; 0
     57c:	90 e0       	ldi	r25, 0x00	; 0
     57e:	60 50       	subi	r22, 0x00	; 0
     580:	70 48       	sbci	r23, 0x80	; 128
     582:	8f 4e       	sbci	r24, 0xEF	; 239
     584:	9f 4f       	sbci	r25, 0xFF	; 255
     586:	20 e0       	ldi	r18, 0x00	; 0
     588:	30 e0       	ldi	r19, 0x00	; 0
     58a:	40 e0       	ldi	r20, 0x00	; 0
     58c:	52 e0       	ldi	r21, 0x02	; 2
     58e:	e2 2a       	or	r14, r18
     590:	f3 2a       	or	r15, r19
     592:	04 2b       	or	r16, r20
     594:	15 2b       	or	r17, r21
     596:	a8 01       	movw	r20, r16
     598:	97 01       	movw	r18, r14
     59a:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     59e:	80 91 3a 01 	lds	r24, 0x013A
     5a2:	90 91 3b 01 	lds	r25, 0x013B
     5a6:	bc 01       	movw	r22, r24
     5a8:	6c 5f       	subi	r22, 0xFC	; 252
     5aa:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     5ac:	30 e1       	ldi	r19, 0x10	; 16
     5ae:	60 30       	cpi	r22, 0x00	; 0
     5b0:	73 07       	cpc	r23, r19
     5b2:	18 f0       	brcs	.+6      	; 0x5ba <Start_CMDList+0x94>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     5b4:	bc 01       	movw	r22, r24
     5b6:	6c 5f       	subi	r22, 0xFC	; 252
     5b8:	7f 40       	sbci	r23, 0x0F	; 15

     FT800memWrite32(RAM_CMD + cmdOffset,CMD_DLSTART)                   ; //*** Sent Co-CMD Start the display list                                                     
     cmdOffset = incCMDOffset(cmdOffset,4)                              ; //Update Offset pointer Ram-CMD 4 byte for Next CMD     
    
     FT800memWrite32(RAM_CMD + cmdOffset,(DL_CLEAR_RGB | screen_color)) ; //*** Sent DL-CMD Clear color BackGround and Set Color BackGround                  
     cmdOffset = incCMDOffset(cmdOffset,4)                              ; //Update Offset pointer Ram-CMD 4 byte for Next CMD
     5ba:	70 93 3b 01 	sts	0x013B, r23
     5be:	60 93 3a 01 	sts	0x013A, r22

     FT800memWrite32(RAM_CMD + cmdOffset,(DL_CLEAR | CLR_COL | CLR_STN | CLR_TAG));   //*** Sent DL-CMD Clear the screen - this and the previous prevent artifacts between lists                                                                               // Attributes are the color, stencil and tag buffers
     5c2:	80 e0       	ldi	r24, 0x00	; 0
     5c4:	90 e0       	ldi	r25, 0x00	; 0
     5c6:	60 50       	subi	r22, 0x00	; 0
     5c8:	70 48       	sbci	r23, 0x80	; 128
     5ca:	8f 4e       	sbci	r24, 0xEF	; 239
     5cc:	9f 4f       	sbci	r25, 0xFF	; 255
     5ce:	27 e0       	ldi	r18, 0x07	; 7
     5d0:	30 e0       	ldi	r19, 0x00	; 0
     5d2:	40 e0       	ldi	r20, 0x00	; 0
     5d4:	56 e2       	ldi	r21, 0x26	; 38
     5d6:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     5da:	20 91 3a 01 	lds	r18, 0x013A
     5de:	30 91 3b 01 	lds	r19, 0x013B
     5e2:	c9 01       	movw	r24, r18
     5e4:	04 96       	adiw	r24, 0x04	; 4

    if(newOffset > 4095)                        //If new offset past boundary...
     5e6:	40 e1       	ldi	r20, 0x10	; 16
     5e8:	80 30       	cpi	r24, 0x00	; 0
     5ea:	94 07       	cpc	r25, r20
     5ec:	18 f0       	brcs	.+6      	; 0x5f4 <Start_CMDList+0xce>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     5ee:	c9 01       	movw	r24, r18
     5f0:	8c 5f       	subi	r24, 0xFC	; 252
     5f2:	9f 40       	sbci	r25, 0x0F	; 15
    
     FT800memWrite32(RAM_CMD + cmdOffset,(DL_CLEAR_RGB | screen_color)) ; //*** Sent DL-CMD Clear color BackGround and Set Color BackGround                  
     cmdOffset = incCMDOffset(cmdOffset,4)                              ; //Update Offset pointer Ram-CMD 4 byte for Next CMD

     FT800memWrite32(RAM_CMD + cmdOffset,(DL_CLEAR | CLR_COL | CLR_STN | CLR_TAG));   //*** Sent DL-CMD Clear the screen - this and the previous prevent artifacts between lists                                                                               // Attributes are the color, stencil and tag buffers
     cmdOffset = incCMDOffset(cmdOffset,4)                              ;           //Update Offset pointer Ram-CMD 4 byte for Next CMD
     5f4:	90 93 3b 01 	sts	0x013B, r25
     5f8:	80 93 3a 01 	sts	0x013A, r24

   }
     5fc:	1f 91       	pop	r17
     5fe:	0f 91       	pop	r16
     600:	ff 90       	pop	r15
     602:	ef 90       	pop	r14
     604:	08 95       	ret

00000606 <End_CMDList>:

  void End_CMDList(void)               
  {
    //----------------- End Display List and Update Execute -----------------

    FT800memWrite32(RAM_CMD + cmdOffset,DL_DISPLAY)          ;//*** Sent DL-CMD End Display List                  
     606:	60 91 3a 01 	lds	r22, 0x013A
     60a:	70 91 3b 01 	lds	r23, 0x013B
     60e:	80 e0       	ldi	r24, 0x00	; 0
     610:	90 e0       	ldi	r25, 0x00	; 0
     612:	60 50       	subi	r22, 0x00	; 0
     614:	70 48       	sbci	r23, 0x80	; 128
     616:	8f 4e       	sbci	r24, 0xEF	; 239
     618:	9f 4f       	sbci	r25, 0xFF	; 255
     61a:	20 e0       	ldi	r18, 0x00	; 0
     61c:	30 e0       	ldi	r19, 0x00	; 0
     61e:	40 e0       	ldi	r20, 0x00	; 0
     620:	50 e0       	ldi	r21, 0x00	; 0
     622:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     626:	80 91 3a 01 	lds	r24, 0x013A
     62a:	90 91 3b 01 	lds	r25, 0x013B
     62e:	bc 01       	movw	r22, r24
     630:	6c 5f       	subi	r22, 0xFC	; 252
     632:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     634:	20 e1       	ldi	r18, 0x10	; 16
     636:	60 30       	cpi	r22, 0x00	; 0
     638:	72 07       	cpc	r23, r18
     63a:	18 f0       	brcs	.+6      	; 0x642 <End_CMDList+0x3c>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     63c:	bc 01       	movw	r22, r24
     63e:	6c 5f       	subi	r22, 0xFC	; 252
     640:	7f 40       	sbci	r23, 0x0F	; 15
  void End_CMDList(void)               
  {
    //----------------- End Display List and Update Execute -----------------

    FT800memWrite32(RAM_CMD + cmdOffset,DL_DISPLAY)          ;//*** Sent DL-CMD End Display List                  
    cmdOffset = incCMDOffset(cmdOffset,4)                    ;//Update Offset pointer Ram-CMD 4 byte for Next CMD
     642:	70 93 3b 01 	sts	0x013B, r23
     646:	60 93 3a 01 	sts	0x013A, r22
 
    FT800memWrite32(RAM_CMD + cmdOffset,CMD_SWAP)            ;//*** Sent Co-CMD Requse Display List Swap
     64a:	80 e0       	ldi	r24, 0x00	; 0
     64c:	90 e0       	ldi	r25, 0x00	; 0
     64e:	60 50       	subi	r22, 0x00	; 0
     650:	70 48       	sbci	r23, 0x80	; 128
     652:	8f 4e       	sbci	r24, 0xEF	; 239
     654:	9f 4f       	sbci	r25, 0xFF	; 255
     656:	21 e0       	ldi	r18, 0x01	; 1
     658:	3f ef       	ldi	r19, 0xFF	; 255
     65a:	4f ef       	ldi	r20, 0xFF	; 255
     65c:	5f ef       	ldi	r21, 0xFF	; 255
     65e:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     662:	80 91 3a 01 	lds	r24, 0x013A
     666:	90 91 3b 01 	lds	r25, 0x013B
     66a:	ac 01       	movw	r20, r24
     66c:	4c 5f       	subi	r20, 0xFC	; 252
     66e:	5f 4f       	sbci	r21, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     670:	20 e1       	ldi	r18, 0x10	; 16
     672:	40 30       	cpi	r20, 0x00	; 0
     674:	52 07       	cpc	r21, r18
     676:	18 f0       	brcs	.+6      	; 0x67e <End_CMDList+0x78>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     678:	ac 01       	movw	r20, r24
     67a:	4c 5f       	subi	r20, 0xFC	; 252
     67c:	5f 40       	sbci	r21, 0x0F	; 15

    FT800memWrite32(RAM_CMD + cmdOffset,DL_DISPLAY)          ;//*** Sent DL-CMD End Display List                  
    cmdOffset = incCMDOffset(cmdOffset,4)                    ;//Update Offset pointer Ram-CMD 4 byte for Next CMD
 
    FT800memWrite32(RAM_CMD + cmdOffset,CMD_SWAP)            ;//*** Sent Co-CMD Requse Display List Swap
    cmdOffset = incCMDOffset(cmdOffset,4)                    ;//Update Offset pointer Ram-CMD 4 byte for Next CMD
     67e:	50 93 3b 01 	sts	0x013B, r21
     682:	40 93 3a 01 	sts	0x013A, r20

    FT800memWrite16(REG_CMD_WRITE,cmdOffset)                 ;//*** Sent Data cmdOffset to reg. CMD_Write for
     686:	68 ee       	ldi	r22, 0xE8	; 232
     688:	74 e2       	ldi	r23, 0x24	; 36
     68a:	80 e1       	ldi	r24, 0x10	; 16
     68c:	90 e0       	ldi	r25, 0x00	; 0
     68e:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>
                                                             //Update the ring buffer pointer so the graphics processor starts executing
  } 
     692:	08 95       	ret

00000694 <Background_DL>:
  ++     8.3) Function:Display-List Set Background  (Write Program to Ram_DL)     ++
  ++                                                                              ++                                                                       
  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

  void Background_DL(long bg_color)               
  {
     694:	9b 01       	movw	r18, r22
     696:	ac 01       	movw	r20, r24

   FT800memWrite32(RAM_DL,(DL_CLEAR_RGB | bg_color))        ; //*** Sent DL-CMD Set Background Color  
     698:	52 60       	ori	r21, 0x02	; 2
     69a:	60 e0       	ldi	r22, 0x00	; 0
     69c:	70 e0       	ldi	r23, 0x00	; 0
     69e:	80 e1       	ldi	r24, 0x10	; 16
     6a0:	90 e0       	ldi	r25, 0x00	; 0
     6a2:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>
     
  } 
     6a6:	08 95       	ret

000006a8 <Keys_CMD>:
  ++  Note : The gap between keys is 3 pixels                                     ++
  ++                                                                              ++
  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

void Keys_CMD(char *str,int x,int y,int wide,int high,int font,int opt,long tx_color,long key_color)
 {
     6a8:	2f 92       	push	r2
     6aa:	3f 92       	push	r3
     6ac:	4f 92       	push	r4
     6ae:	5f 92       	push	r5
     6b0:	6f 92       	push	r6
     6b2:	7f 92       	push	r7
     6b4:	8f 92       	push	r8
     6b6:	9f 92       	push	r9
     6b8:	af 92       	push	r10
     6ba:	bf 92       	push	r11
     6bc:	cf 92       	push	r12
     6be:	df 92       	push	r13
     6c0:	ef 92       	push	r14
     6c2:	ff 92       	push	r15
     6c4:	0f 93       	push	r16
     6c6:	1f 93       	push	r17
     6c8:	df 93       	push	r29
     6ca:	cf 93       	push	r28
     6cc:	00 d0       	rcall	.+0      	; 0x6ce <Keys_CMD+0x26>
     6ce:	cd b7       	in	r28, 0x3d	; 61
     6d0:	de b7       	in	r29, 0x3e	; 62
     6d2:	9a 83       	std	Y+2, r25	; 0x02
     6d4:	89 83       	std	Y+1, r24	; 0x01
     6d6:	3b 01       	movw	r6, r22
     6d8:	2a 01       	movw	r4, r20
     6da:	19 01       	movw	r2, r18
     6dc:	a5 01       	movw	r20, r10
     6de:	94 01       	movw	r18, r8

      // Set Attribute Button //

   FT800memWrite32(RAM_CMD + cmdOffset,(DL_COLOR_RGB | tx_color))      ; //*** Sent DL-CMD Set Color Text              
     6e0:	60 91 3a 01 	lds	r22, 0x013A
     6e4:	70 91 3b 01 	lds	r23, 0x013B
     6e8:	80 e0       	ldi	r24, 0x00	; 0
     6ea:	90 e0       	ldi	r25, 0x00	; 0
     6ec:	60 50       	subi	r22, 0x00	; 0
     6ee:	70 48       	sbci	r23, 0x80	; 128
     6f0:	8f 4e       	sbci	r24, 0xEF	; 239
     6f2:	9f 4f       	sbci	r25, 0xFF	; 255
     6f4:	54 60       	ori	r21, 0x04	; 4
     6f6:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     6fa:	80 91 3a 01 	lds	r24, 0x013A
     6fe:	90 91 3b 01 	lds	r25, 0x013B
     702:	bc 01       	movw	r22, r24
     704:	6c 5f       	subi	r22, 0xFC	; 252
     706:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     708:	20 e1       	ldi	r18, 0x10	; 16
     70a:	60 30       	cpi	r22, 0x00	; 0
     70c:	72 07       	cpc	r23, r18
     70e:	18 f0       	brcs	.+6      	; 0x716 <Keys_CMD+0x6e>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     710:	bc 01       	movw	r22, r24
     712:	6c 5f       	subi	r22, 0xFC	; 252
     714:	7f 40       	sbci	r23, 0x0F	; 15
 {

      // Set Attribute Button //

   FT800memWrite32(RAM_CMD + cmdOffset,(DL_COLOR_RGB | tx_color))      ; //*** Sent DL-CMD Set Color Text              
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next CMD
     716:	70 93 3b 01 	sts	0x013B, r23
     71a:	60 93 3a 01 	sts	0x013A, r22


    FT800memWrite32(RAM_CMD + cmdOffset,CMD_FGCOLOR)                    ; //*** Sent Co-CMD Set Color Button                                                  
     71e:	80 e0       	ldi	r24, 0x00	; 0
     720:	90 e0       	ldi	r25, 0x00	; 0
     722:	60 50       	subi	r22, 0x00	; 0
     724:	70 48       	sbci	r23, 0x80	; 128
     726:	8f 4e       	sbci	r24, 0xEF	; 239
     728:	9f 4f       	sbci	r25, 0xFF	; 255
     72a:	2a e0       	ldi	r18, 0x0A	; 10
     72c:	3f ef       	ldi	r19, 0xFF	; 255
     72e:	4f ef       	ldi	r20, 0xFF	; 255
     730:	5f ef       	ldi	r21, 0xFF	; 255
     732:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     736:	80 91 3a 01 	lds	r24, 0x013A
     73a:	90 91 3b 01 	lds	r25, 0x013B
     73e:	bc 01       	movw	r22, r24
     740:	6c 5f       	subi	r22, 0xFC	; 252
     742:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     744:	20 e1       	ldi	r18, 0x10	; 16
     746:	60 30       	cpi	r22, 0x00	; 0
     748:	72 07       	cpc	r23, r18
     74a:	18 f0       	brcs	.+6      	; 0x752 <Keys_CMD+0xaa>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     74c:	bc 01       	movw	r22, r24
     74e:	6c 5f       	subi	r22, 0xFC	; 252
     750:	7f 40       	sbci	r23, 0x0F	; 15
   FT800memWrite32(RAM_CMD + cmdOffset,(DL_COLOR_RGB | tx_color))      ; //*** Sent DL-CMD Set Color Text              
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next CMD


    FT800memWrite32(RAM_CMD + cmdOffset,CMD_FGCOLOR)                    ; //*** Sent Co-CMD Set Color Button                                                  
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next CMD
     752:	70 93 3b 01 	sts	0x013B, r23
     756:	60 93 3a 01 	sts	0x013A, r22
   
    FT800memWrite32(RAM_CMD + cmdOffset,key_color)                      ; //---Sent Data Color Button
     75a:	80 e0       	ldi	r24, 0x00	; 0
     75c:	90 e0       	ldi	r25, 0x00	; 0
     75e:	60 50       	subi	r22, 0x00	; 0
     760:	70 48       	sbci	r23, 0x80	; 128
     762:	8f 4e       	sbci	r24, 0xEF	; 239
     764:	9f 4f       	sbci	r25, 0xFF	; 255
     766:	2f 89       	ldd	r18, Y+23	; 0x17
     768:	38 8d       	ldd	r19, Y+24	; 0x18
     76a:	49 8d       	ldd	r20, Y+25	; 0x19
     76c:	5a 8d       	ldd	r21, Y+26	; 0x1a
     76e:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     772:	80 91 3a 01 	lds	r24, 0x013A
     776:	90 91 3b 01 	lds	r25, 0x013B
     77a:	bc 01       	movw	r22, r24
     77c:	6c 5f       	subi	r22, 0xFC	; 252
     77e:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     780:	20 e1       	ldi	r18, 0x10	; 16
     782:	60 30       	cpi	r22, 0x00	; 0
     784:	72 07       	cpc	r23, r18
     786:	18 f0       	brcs	.+6      	; 0x78e <Keys_CMD+0xe6>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     788:	bc 01       	movw	r22, r24
     78a:	6c 5f       	subi	r22, 0xFC	; 252
     78c:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite32(RAM_CMD + cmdOffset,CMD_FGCOLOR)                    ; //*** Sent Co-CMD Set Color Button                                                  
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next CMD
   
    FT800memWrite32(RAM_CMD + cmdOffset,key_color)                      ; //---Sent Data Color Button
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next CMD
     78e:	70 93 3b 01 	sts	0x013B, r23
     792:	60 93 3a 01 	sts	0x013A, r22

    // Start Draw Button1 //   

    FT800memWrite32(RAM_CMD + cmdOffset,CMD_KEYS)                       ; //***Sent Co-CMD Build Button
     796:	80 e0       	ldi	r24, 0x00	; 0
     798:	90 e0       	ldi	r25, 0x00	; 0
     79a:	60 50       	subi	r22, 0x00	; 0
     79c:	70 48       	sbci	r23, 0x80	; 128
     79e:	8f 4e       	sbci	r24, 0xEF	; 239
     7a0:	9f 4f       	sbci	r25, 0xFF	; 255
     7a2:	2e e0       	ldi	r18, 0x0E	; 14
     7a4:	3f ef       	ldi	r19, 0xFF	; 255
     7a6:	4f ef       	ldi	r20, 0xFF	; 255
     7a8:	5f ef       	ldi	r21, 0xFF	; 255
     7aa:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     7ae:	80 91 3a 01 	lds	r24, 0x013A
     7b2:	90 91 3b 01 	lds	r25, 0x013B
     7b6:	bc 01       	movw	r22, r24
     7b8:	6c 5f       	subi	r22, 0xFC	; 252
     7ba:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     7bc:	20 e1       	ldi	r18, 0x10	; 16
     7be:	60 30       	cpi	r22, 0x00	; 0
     7c0:	72 07       	cpc	r23, r18
     7c2:	18 f0       	brcs	.+6      	; 0x7ca <Keys_CMD+0x122>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     7c4:	bc 01       	movw	r22, r24
     7c6:	6c 5f       	subi	r22, 0xFC	; 252
     7c8:	7f 40       	sbci	r23, 0x0F	; 15
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next CMD

    // Start Draw Button1 //   

    FT800memWrite32(RAM_CMD + cmdOffset,CMD_KEYS)                       ; //***Sent Co-CMD Build Button
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next Data
     7ca:	70 93 3b 01 	sts	0x013B, r23
     7ce:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite16(RAM_CMD + cmdOffset,x)                              ; //---Sent data X-Point top-left (Pixel) 
     7d2:	80 e0       	ldi	r24, 0x00	; 0
     7d4:	90 e0       	ldi	r25, 0x00	; 0
     7d6:	60 50       	subi	r22, 0x00	; 0
     7d8:	70 48       	sbci	r23, 0x80	; 128
     7da:	8f 4e       	sbci	r24, 0xEF	; 239
     7dc:	9f 4f       	sbci	r25, 0xFF	; 255
     7de:	a3 01       	movw	r20, r6
     7e0:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     7e4:	80 91 3a 01 	lds	r24, 0x013A
     7e8:	90 91 3b 01 	lds	r25, 0x013B
     7ec:	bc 01       	movw	r22, r24
     7ee:	6e 5f       	subi	r22, 0xFE	; 254
     7f0:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     7f2:	20 e1       	ldi	r18, 0x10	; 16
     7f4:	60 30       	cpi	r22, 0x00	; 0
     7f6:	72 07       	cpc	r23, r18
     7f8:	18 f0       	brcs	.+6      	; 0x800 <Keys_CMD+0x158>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     7fa:	bc 01       	movw	r22, r24
     7fc:	6e 5f       	subi	r22, 0xFE	; 254
     7fe:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite32(RAM_CMD + cmdOffset,CMD_KEYS)                       ; //***Sent Co-CMD Build Button
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next Data

    FT800memWrite16(RAM_CMD + cmdOffset,x)                              ; //---Sent data X-Point top-left (Pixel) 
    cmdOffset = incCMDOffset(cmdOffset,2)                               ; //Update Offset pointer Ram-CMD 2 byte for Next Data
     800:	70 93 3b 01 	sts	0x013B, r23
     804:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite16(RAM_CMD + cmdOffset,y)                              ; //---Sent data Y-Point  top-left (Pixel)
     808:	80 e0       	ldi	r24, 0x00	; 0
     80a:	90 e0       	ldi	r25, 0x00	; 0
     80c:	60 50       	subi	r22, 0x00	; 0
     80e:	70 48       	sbci	r23, 0x80	; 128
     810:	8f 4e       	sbci	r24, 0xEF	; 239
     812:	9f 4f       	sbci	r25, 0xFF	; 255
     814:	a2 01       	movw	r20, r4
     816:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     81a:	80 91 3a 01 	lds	r24, 0x013A
     81e:	90 91 3b 01 	lds	r25, 0x013B
     822:	bc 01       	movw	r22, r24
     824:	6e 5f       	subi	r22, 0xFE	; 254
     826:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     828:	20 e1       	ldi	r18, 0x10	; 16
     82a:	60 30       	cpi	r22, 0x00	; 0
     82c:	72 07       	cpc	r23, r18
     82e:	18 f0       	brcs	.+6      	; 0x836 <Keys_CMD+0x18e>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     830:	bc 01       	movw	r22, r24
     832:	6e 5f       	subi	r22, 0xFE	; 254
     834:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite16(RAM_CMD + cmdOffset,x)                              ; //---Sent data X-Point top-left (Pixel) 
    cmdOffset = incCMDOffset(cmdOffset,2)                               ; //Update Offset pointer Ram-CMD 2 byte for Next Data

    FT800memWrite16(RAM_CMD + cmdOffset,y)                              ; //---Sent data Y-Point  top-left (Pixel)
    cmdOffset = incCMDOffset(cmdOffset,2)                               ; //Update Offset pointer Ram-CMD 2 byte for Next Data
     836:	70 93 3b 01 	sts	0x013B, r23
     83a:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite16(RAM_CMD + cmdOffset,wide)                           ; //---Sent data wide-Button (pixel)
     83e:	80 e0       	ldi	r24, 0x00	; 0
     840:	90 e0       	ldi	r25, 0x00	; 0
     842:	60 50       	subi	r22, 0x00	; 0
     844:	70 48       	sbci	r23, 0x80	; 128
     846:	8f 4e       	sbci	r24, 0xEF	; 239
     848:	9f 4f       	sbci	r25, 0xFF	; 255
     84a:	a1 01       	movw	r20, r2
     84c:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     850:	80 91 3a 01 	lds	r24, 0x013A
     854:	90 91 3b 01 	lds	r25, 0x013B
     858:	bc 01       	movw	r22, r24
     85a:	6e 5f       	subi	r22, 0xFE	; 254
     85c:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     85e:	20 e1       	ldi	r18, 0x10	; 16
     860:	60 30       	cpi	r22, 0x00	; 0
     862:	72 07       	cpc	r23, r18
     864:	18 f0       	brcs	.+6      	; 0x86c <Keys_CMD+0x1c4>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     866:	bc 01       	movw	r22, r24
     868:	6e 5f       	subi	r22, 0xFE	; 254
     86a:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite16(RAM_CMD + cmdOffset,y)                              ; //---Sent data Y-Point  top-left (Pixel)
    cmdOffset = incCMDOffset(cmdOffset,2)                               ; //Update Offset pointer Ram-CMD 2 byte for Next Data

    FT800memWrite16(RAM_CMD + cmdOffset,wide)                           ; //---Sent data wide-Button (pixel)
    cmdOffset = incCMDOffset(cmdOffset,2)                               ; //Update Offset pointer Ram-CMD 2 byte for Next Data
     86c:	70 93 3b 01 	sts	0x013B, r23
     870:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite16(RAM_CMD + cmdOffset,high)                           ; //---Sent data high-Button (Pixel)                                                     
     874:	80 e0       	ldi	r24, 0x00	; 0
     876:	90 e0       	ldi	r25, 0x00	; 0
     878:	60 50       	subi	r22, 0x00	; 0
     87a:	70 48       	sbci	r23, 0x80	; 128
     87c:	8f 4e       	sbci	r24, 0xEF	; 239
     87e:	9f 4f       	sbci	r25, 0xFF	; 255
     880:	a8 01       	movw	r20, r16
     882:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     886:	80 91 3a 01 	lds	r24, 0x013A
     88a:	90 91 3b 01 	lds	r25, 0x013B
     88e:	bc 01       	movw	r22, r24
     890:	6e 5f       	subi	r22, 0xFE	; 254
     892:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     894:	20 e1       	ldi	r18, 0x10	; 16
     896:	60 30       	cpi	r22, 0x00	; 0
     898:	72 07       	cpc	r23, r18
     89a:	18 f0       	brcs	.+6      	; 0x8a2 <Keys_CMD+0x1fa>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     89c:	bc 01       	movw	r22, r24
     89e:	6e 5f       	subi	r22, 0xFE	; 254
     8a0:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite16(RAM_CMD + cmdOffset,wide)                           ; //---Sent data wide-Button (pixel)
    cmdOffset = incCMDOffset(cmdOffset,2)                               ; //Update Offset pointer Ram-CMD 2 byte for Next Data

    FT800memWrite16(RAM_CMD + cmdOffset,high)                           ; //---Sent data high-Button (Pixel)                                                     
    cmdOffset = incCMDOffset(cmdOffset,2)                               ; //Update Offset pointer Ram-CMD 2 byte for Next Data
     8a2:	70 93 3b 01 	sts	0x013B, r23
     8a6:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite16(RAM_CMD + cmdOffset,font)                           ; //---Sent data format font in Button label (16,18,20,21,22...)                                                     
     8aa:	80 e0       	ldi	r24, 0x00	; 0
     8ac:	90 e0       	ldi	r25, 0x00	; 0
     8ae:	60 50       	subi	r22, 0x00	; 0
     8b0:	70 48       	sbci	r23, 0x80	; 128
     8b2:	8f 4e       	sbci	r24, 0xEF	; 239
     8b4:	9f 4f       	sbci	r25, 0xFF	; 255
     8b6:	a7 01       	movw	r20, r14
     8b8:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     8bc:	80 91 3a 01 	lds	r24, 0x013A
     8c0:	90 91 3b 01 	lds	r25, 0x013B
     8c4:	bc 01       	movw	r22, r24
     8c6:	6e 5f       	subi	r22, 0xFE	; 254
     8c8:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     8ca:	20 e1       	ldi	r18, 0x10	; 16
     8cc:	60 30       	cpi	r22, 0x00	; 0
     8ce:	72 07       	cpc	r23, r18
     8d0:	18 f0       	brcs	.+6      	; 0x8d8 <Keys_CMD+0x230>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     8d2:	bc 01       	movw	r22, r24
     8d4:	6e 5f       	subi	r22, 0xFE	; 254
     8d6:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite16(RAM_CMD + cmdOffset,high)                           ; //---Sent data high-Button (Pixel)                                                     
    cmdOffset = incCMDOffset(cmdOffset,2)                               ; //Update Offset pointer Ram-CMD 2 byte for Next Data

    FT800memWrite16(RAM_CMD + cmdOffset,font)                           ; //---Sent data format font in Button label (16,18,20,21,22...)                                                     
    cmdOffset = incCMDOffset(cmdOffset,2)                               ; //Update Offset pointer Ram-CMD 2 byte for Next Data
     8d8:	70 93 3b 01 	sts	0x013B, r23
     8dc:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite16(RAM_CMD + cmdOffset,opt)                            ; //---Sent data Option Button Drawn 3D                                                     
     8e0:	80 e0       	ldi	r24, 0x00	; 0
     8e2:	90 e0       	ldi	r25, 0x00	; 0
     8e4:	60 50       	subi	r22, 0x00	; 0
     8e6:	70 48       	sbci	r23, 0x80	; 128
     8e8:	8f 4e       	sbci	r24, 0xEF	; 239
     8ea:	9f 4f       	sbci	r25, 0xFF	; 255
     8ec:	a6 01       	movw	r20, r12
     8ee:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     8f2:	80 91 3a 01 	lds	r24, 0x013A
     8f6:	90 91 3b 01 	lds	r25, 0x013B
     8fa:	bc 01       	movw	r22, r24
     8fc:	6e 5f       	subi	r22, 0xFE	; 254
     8fe:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     900:	20 e1       	ldi	r18, 0x10	; 16
     902:	60 30       	cpi	r22, 0x00	; 0
     904:	72 07       	cpc	r23, r18
     906:	18 f0       	brcs	.+6      	; 0x90e <Keys_CMD+0x266>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     908:	bc 01       	movw	r22, r24
     90a:	6e 5f       	subi	r22, 0xFE	; 254
     90c:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite16(RAM_CMD + cmdOffset,font)                           ; //---Sent data format font in Button label (16,18,20,21,22...)                                                     
    cmdOffset = incCMDOffset(cmdOffset,2)                               ; //Update Offset pointer Ram-CMD 2 byte for Next Data

    FT800memWrite16(RAM_CMD + cmdOffset,opt)                            ; //---Sent data Option Button Drawn 3D                                                     
    cmdOffset = incCMDOffset(cmdOffset,2)                               ; //Update Offset pointer Ram-CMD 2 byte for Next Data
     90e:	70 93 3b 01 	sts	0x013B, r23
     912:	60 93 3a 01 	sts	0x013A, r22

    FT800memWriteStr(RAM_CMD + cmdOffset,str)                           ; //---Sent data Text Button Label (String)
     916:	80 e0       	ldi	r24, 0x00	; 0
     918:	90 e0       	ldi	r25, 0x00	; 0
     91a:	60 50       	subi	r22, 0x00	; 0
     91c:	70 48       	sbci	r23, 0x80	; 128
     91e:	8f 4e       	sbci	r24, 0xEF	; 239
     920:	9f 4f       	sbci	r25, 0xFF	; 255
     922:	49 81       	ldd	r20, Y+1	; 0x01
     924:	5a 81       	ldd	r21, Y+2	; 0x02
     926:	0e 94 1d 01 	call	0x23a	; 0x23a <FT800memWriteStr>

unsigned int End_incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
  unsigned int newOffset                   ;  //used to hold new offset

   newOffset = currentOffset + commandSize ;  //Calculate new offset
     92a:	80 91 41 01 	lds	r24, 0x0141
     92e:	20 91 3a 01 	lds	r18, 0x013A
     932:	30 91 3b 01 	lds	r19, 0x013B
     936:	28 0f       	add	r18, r24
     938:	31 1d       	adc	r19, r1

   if(newOffset > 4095)                       //If new offset past boundary...
     93a:	80 e1       	ldi	r24, 0x10	; 16
     93c:	20 30       	cpi	r18, 0x00	; 0
     93e:	38 07       	cpc	r19, r24
     940:	10 f0       	brcs	.+4      	; 0x946 <Keys_CMD+0x29e>
    {
        newOffset = (newOffset - 4096)     ;  //... roll over pointer
     942:	20 50       	subi	r18, 0x00	; 0
     944:	30 41       	sbci	r19, 0x10	; 16
    }
   

  //increment the length and align it by 4 bytes//

   newOffset = (newOffset+3) & 4092        ;
     946:	2d 5f       	subi	r18, 0xFD	; 253
     948:	3f 4f       	sbci	r19, 0xFF	; 255

    FT800memWrite16(RAM_CMD + cmdOffset,opt)                            ; //---Sent data Option Button Drawn 3D                                                     
    cmdOffset = incCMDOffset(cmdOffset,2)                               ; //Update Offset pointer Ram-CMD 2 byte for Next Data

    FT800memWriteStr(RAM_CMD + cmdOffset,str)                           ; //---Sent data Text Button Label (String)
    cmdOffset = End_incCMDOffset(cmdOffset,num_cha)                     ; //Update Offset pointer Ram-CMD for End CMD-Button  
     94a:	2c 7f       	andi	r18, 0xFC	; 252
     94c:	3f 70       	andi	r19, 0x0F	; 15
     94e:	30 93 3b 01 	sts	0x013B, r19
     952:	20 93 3a 01 	sts	0x013A, r18
 
 }
     956:	0f 90       	pop	r0
     958:	0f 90       	pop	r0
     95a:	cf 91       	pop	r28
     95c:	df 91       	pop	r29
     95e:	1f 91       	pop	r17
     960:	0f 91       	pop	r16
     962:	ff 90       	pop	r15
     964:	ef 90       	pop	r14
     966:	df 90       	pop	r13
     968:	cf 90       	pop	r12
     96a:	bf 90       	pop	r11
     96c:	af 90       	pop	r10
     96e:	9f 90       	pop	r9
     970:	8f 90       	pop	r8
     972:	7f 90       	pop	r7
     974:	6f 90       	pop	r6
     976:	5f 90       	pop	r5
     978:	4f 90       	pop	r4
     97a:	3f 90       	pop	r3
     97c:	2f 90       	pop	r2
     97e:	08 95       	ret

00000980 <Text_CMD>:
  ++                                                                              ++
  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/


void Text_CMD(char *str,int x,int y,int font,int opt,long tx_color)
 {
     980:	6f 92       	push	r6
     982:	7f 92       	push	r7
     984:	8f 92       	push	r8
     986:	9f 92       	push	r9
     988:	af 92       	push	r10
     98a:	bf 92       	push	r11
     98c:	cf 92       	push	r12
     98e:	df 92       	push	r13
     990:	ef 92       	push	r14
     992:	ff 92       	push	r15
     994:	0f 93       	push	r16
     996:	1f 93       	push	r17
     998:	cf 93       	push	r28
     99a:	df 93       	push	r29
     99c:	3c 01       	movw	r6, r24
     99e:	eb 01       	movw	r28, r22
     9a0:	5a 01       	movw	r10, r20
     9a2:	49 01       	movw	r8, r18
     9a4:	a7 01       	movw	r20, r14
     9a6:	96 01       	movw	r18, r12

    // Set Attribute Clock //

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_COLOR_RGB | tx_color))    ; //***Sent DL-CMD Set Color Text  
     9a8:	60 91 3a 01 	lds	r22, 0x013A
     9ac:	70 91 3b 01 	lds	r23, 0x013B
     9b0:	80 e0       	ldi	r24, 0x00	; 0
     9b2:	90 e0       	ldi	r25, 0x00	; 0
     9b4:	60 50       	subi	r22, 0x00	; 0
     9b6:	70 48       	sbci	r23, 0x80	; 128
     9b8:	8f 4e       	sbci	r24, 0xEF	; 239
     9ba:	9f 4f       	sbci	r25, 0xFF	; 255
     9bc:	54 60       	ori	r21, 0x04	; 4
     9be:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     9c2:	80 91 3a 01 	lds	r24, 0x013A
     9c6:	90 91 3b 01 	lds	r25, 0x013B
     9ca:	bc 01       	movw	r22, r24
     9cc:	6c 5f       	subi	r22, 0xFC	; 252
     9ce:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     9d0:	20 e1       	ldi	r18, 0x10	; 16
     9d2:	60 30       	cpi	r22, 0x00	; 0
     9d4:	72 07       	cpc	r23, r18
     9d6:	18 f0       	brcs	.+6      	; 0x9de <Text_CMD+0x5e>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     9d8:	bc 01       	movw	r22, r24
     9da:	6c 5f       	subi	r22, 0xFC	; 252
     9dc:	7f 40       	sbci	r23, 0x0F	; 15
 {

    // Set Attribute Clock //

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_COLOR_RGB | tx_color))    ; //***Sent DL-CMD Set Color Text  
    cmdOffset = incCMDOffset(cmdOffset,4)                             ; //Update Offset pointer Ram-CMD 4 byte for Next CMD
     9de:	70 93 3b 01 	sts	0x013B, r23
     9e2:	60 93 3a 01 	sts	0x013A, r22

   
   //Start Draw Text//    

    FT800memWrite32(RAM_CMD + cmdOffset,CMD_TEXT)                     ; //***Sent Co-CMD Draw TEXT
     9e6:	80 e0       	ldi	r24, 0x00	; 0
     9e8:	90 e0       	ldi	r25, 0x00	; 0
     9ea:	60 50       	subi	r22, 0x00	; 0
     9ec:	70 48       	sbci	r23, 0x80	; 128
     9ee:	8f 4e       	sbci	r24, 0xEF	; 239
     9f0:	9f 4f       	sbci	r25, 0xFF	; 255
     9f2:	2c e0       	ldi	r18, 0x0C	; 12
     9f4:	3f ef       	ldi	r19, 0xFF	; 255
     9f6:	4f ef       	ldi	r20, 0xFF	; 255
     9f8:	5f ef       	ldi	r21, 0xFF	; 255
     9fa:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     9fe:	80 91 3a 01 	lds	r24, 0x013A
     a02:	90 91 3b 01 	lds	r25, 0x013B
     a06:	bc 01       	movw	r22, r24
     a08:	6c 5f       	subi	r22, 0xFC	; 252
     a0a:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     a0c:	20 e1       	ldi	r18, 0x10	; 16
     a0e:	60 30       	cpi	r22, 0x00	; 0
     a10:	72 07       	cpc	r23, r18
     a12:	18 f0       	brcs	.+6      	; 0xa1a <Text_CMD+0x9a>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     a14:	bc 01       	movw	r22, r24
     a16:	6c 5f       	subi	r22, 0xFC	; 252
     a18:	7f 40       	sbci	r23, 0x0F	; 15

   
   //Start Draw Text//    

    FT800memWrite32(RAM_CMD + cmdOffset,CMD_TEXT)                     ; //***Sent Co-CMD Draw TEXT
    cmdOffset = incCMDOffset(cmdOffset,4)                             ; //Update Offset pointer Ram-CMD 4 byte for Next data
     a1a:	70 93 3b 01 	sts	0x013B, r23
     a1e:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite16(RAM_CMD + cmdOffset,x)                            ; //---Sent data X-Point top-left (Pixel) 
     a22:	80 e0       	ldi	r24, 0x00	; 0
     a24:	90 e0       	ldi	r25, 0x00	; 0
     a26:	60 50       	subi	r22, 0x00	; 0
     a28:	70 48       	sbci	r23, 0x80	; 128
     a2a:	8f 4e       	sbci	r24, 0xEF	; 239
     a2c:	9f 4f       	sbci	r25, 0xFF	; 255
     a2e:	ae 01       	movw	r20, r28
     a30:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     a34:	80 91 3a 01 	lds	r24, 0x013A
     a38:	90 91 3b 01 	lds	r25, 0x013B
     a3c:	bc 01       	movw	r22, r24
     a3e:	6e 5f       	subi	r22, 0xFE	; 254
     a40:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     a42:	20 e1       	ldi	r18, 0x10	; 16
     a44:	60 30       	cpi	r22, 0x00	; 0
     a46:	72 07       	cpc	r23, r18
     a48:	18 f0       	brcs	.+6      	; 0xa50 <Text_CMD+0xd0>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     a4a:	bc 01       	movw	r22, r24
     a4c:	6e 5f       	subi	r22, 0xFE	; 254
     a4e:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite32(RAM_CMD + cmdOffset,CMD_TEXT)                     ; //***Sent Co-CMD Draw TEXT
    cmdOffset = incCMDOffset(cmdOffset,4)                             ; //Update Offset pointer Ram-CMD 4 byte for Next data

    FT800memWrite16(RAM_CMD + cmdOffset,x)                            ; //---Sent data X-Point top-left (Pixel) 
    cmdOffset = incCMDOffset(cmdOffset,2)                             ; //Update Offset pointer Ram-CMD 2 byte for Next data
     a50:	70 93 3b 01 	sts	0x013B, r23
     a54:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite16(RAM_CMD + cmdOffset,y)                            ; //---Sent data Y-Point top-left (Pixel) 
     a58:	80 e0       	ldi	r24, 0x00	; 0
     a5a:	90 e0       	ldi	r25, 0x00	; 0
     a5c:	60 50       	subi	r22, 0x00	; 0
     a5e:	70 48       	sbci	r23, 0x80	; 128
     a60:	8f 4e       	sbci	r24, 0xEF	; 239
     a62:	9f 4f       	sbci	r25, 0xFF	; 255
     a64:	a5 01       	movw	r20, r10
     a66:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     a6a:	80 91 3a 01 	lds	r24, 0x013A
     a6e:	90 91 3b 01 	lds	r25, 0x013B
     a72:	bc 01       	movw	r22, r24
     a74:	6e 5f       	subi	r22, 0xFE	; 254
     a76:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     a78:	20 e1       	ldi	r18, 0x10	; 16
     a7a:	60 30       	cpi	r22, 0x00	; 0
     a7c:	72 07       	cpc	r23, r18
     a7e:	18 f0       	brcs	.+6      	; 0xa86 <Text_CMD+0x106>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     a80:	bc 01       	movw	r22, r24
     a82:	6e 5f       	subi	r22, 0xFE	; 254
     a84:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite16(RAM_CMD + cmdOffset,x)                            ; //---Sent data X-Point top-left (Pixel) 
    cmdOffset = incCMDOffset(cmdOffset,2)                             ; //Update Offset pointer Ram-CMD 2 byte for Next data

    FT800memWrite16(RAM_CMD + cmdOffset,y)                            ; //---Sent data Y-Point top-left (Pixel) 
    cmdOffset = incCMDOffset(cmdOffset,2)                             ; //Update Offset pointer Ram-CMD 2 byte for Next data
     a86:	70 93 3b 01 	sts	0x013B, r23
     a8a:	60 93 3a 01 	sts	0x013A, r22
  
    FT800memWrite16(RAM_CMD + cmdOffset,font)                         ; //---Sent data Set format font(16,18,20,21,22,23,24...)                                                     
     a8e:	80 e0       	ldi	r24, 0x00	; 0
     a90:	90 e0       	ldi	r25, 0x00	; 0
     a92:	60 50       	subi	r22, 0x00	; 0
     a94:	70 48       	sbci	r23, 0x80	; 128
     a96:	8f 4e       	sbci	r24, 0xEF	; 239
     a98:	9f 4f       	sbci	r25, 0xFF	; 255
     a9a:	a4 01       	movw	r20, r8
     a9c:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     aa0:	80 91 3a 01 	lds	r24, 0x013A
     aa4:	90 91 3b 01 	lds	r25, 0x013B
     aa8:	bc 01       	movw	r22, r24
     aaa:	6e 5f       	subi	r22, 0xFE	; 254
     aac:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     aae:	20 e1       	ldi	r18, 0x10	; 16
     ab0:	60 30       	cpi	r22, 0x00	; 0
     ab2:	72 07       	cpc	r23, r18
     ab4:	18 f0       	brcs	.+6      	; 0xabc <Text_CMD+0x13c>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     ab6:	bc 01       	movw	r22, r24
     ab8:	6e 5f       	subi	r22, 0xFE	; 254
     aba:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite16(RAM_CMD + cmdOffset,y)                            ; //---Sent data Y-Point top-left (Pixel) 
    cmdOffset = incCMDOffset(cmdOffset,2)                             ; //Update Offset pointer Ram-CMD 2 byte for Next data
  
    FT800memWrite16(RAM_CMD + cmdOffset,font)                         ; //---Sent data Set format font(16,18,20,21,22,23,24...)                                                     
    cmdOffset = incCMDOffset(cmdOffset,2)                             ; //Update Offset pointer Ram-CMD 2 byte for Next data
     abc:	70 93 3b 01 	sts	0x013B, r23
     ac0:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite16(RAM_CMD + cmdOffset,opt)                          ; //---Sent data Option : Position Draw  Text                                                     
     ac4:	80 e0       	ldi	r24, 0x00	; 0
     ac6:	90 e0       	ldi	r25, 0x00	; 0
     ac8:	60 50       	subi	r22, 0x00	; 0
     aca:	70 48       	sbci	r23, 0x80	; 128
     acc:	8f 4e       	sbci	r24, 0xEF	; 239
     ace:	9f 4f       	sbci	r25, 0xFF	; 255
     ad0:	a8 01       	movw	r20, r16
     ad2:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     ad6:	80 91 3a 01 	lds	r24, 0x013A
     ada:	90 91 3b 01 	lds	r25, 0x013B
     ade:	bc 01       	movw	r22, r24
     ae0:	6e 5f       	subi	r22, 0xFE	; 254
     ae2:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     ae4:	20 e1       	ldi	r18, 0x10	; 16
     ae6:	60 30       	cpi	r22, 0x00	; 0
     ae8:	72 07       	cpc	r23, r18
     aea:	18 f0       	brcs	.+6      	; 0xaf2 <Text_CMD+0x172>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     aec:	bc 01       	movw	r22, r24
     aee:	6e 5f       	subi	r22, 0xFE	; 254
     af0:	7f 40       	sbci	r23, 0x0F	; 15
  
    FT800memWrite16(RAM_CMD + cmdOffset,font)                         ; //---Sent data Set format font(16,18,20,21,22,23,24...)                                                     
    cmdOffset = incCMDOffset(cmdOffset,2)                             ; //Update Offset pointer Ram-CMD 2 byte for Next data

    FT800memWrite16(RAM_CMD + cmdOffset,opt)                          ; //---Sent data Option : Position Draw  Text                                                     
    cmdOffset = incCMDOffset(cmdOffset,2)                             ; //Update Offset pointer Ram-CMD 2 byte for Next data
     af2:	70 93 3b 01 	sts	0x013B, r23
     af6:	60 93 3a 01 	sts	0x013A, r22

    FT800memWriteStr(RAM_CMD + cmdOffset,str)                         ; //---Sent data Text   String      
     afa:	80 e0       	ldi	r24, 0x00	; 0
     afc:	90 e0       	ldi	r25, 0x00	; 0
     afe:	60 50       	subi	r22, 0x00	; 0
     b00:	70 48       	sbci	r23, 0x80	; 128
     b02:	8f 4e       	sbci	r24, 0xEF	; 239
     b04:	9f 4f       	sbci	r25, 0xFF	; 255
     b06:	a3 01       	movw	r20, r6
     b08:	0e 94 1d 01 	call	0x23a	; 0x23a <FT800memWriteStr>

unsigned int End_incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
  unsigned int newOffset                   ;  //used to hold new offset

   newOffset = currentOffset + commandSize ;  //Calculate new offset
     b0c:	80 91 41 01 	lds	r24, 0x0141
     b10:	20 91 3a 01 	lds	r18, 0x013A
     b14:	30 91 3b 01 	lds	r19, 0x013B
     b18:	28 0f       	add	r18, r24
     b1a:	31 1d       	adc	r19, r1

   if(newOffset > 4095)                       //If new offset past boundary...
     b1c:	80 e1       	ldi	r24, 0x10	; 16
     b1e:	20 30       	cpi	r18, 0x00	; 0
     b20:	38 07       	cpc	r19, r24
     b22:	10 f0       	brcs	.+4      	; 0xb28 <Text_CMD+0x1a8>
    {
        newOffset = (newOffset - 4096)     ;  //... roll over pointer
     b24:	20 50       	subi	r18, 0x00	; 0
     b26:	30 41       	sbci	r19, 0x10	; 16
    }
   

  //increment the length and align it by 4 bytes//

   newOffset = (newOffset+3) & 4092        ;
     b28:	2d 5f       	subi	r18, 0xFD	; 253
     b2a:	3f 4f       	sbci	r19, 0xFF	; 255

    FT800memWrite16(RAM_CMD + cmdOffset,opt)                          ; //---Sent data Option : Position Draw  Text                                                     
    cmdOffset = incCMDOffset(cmdOffset,2)                             ; //Update Offset pointer Ram-CMD 2 byte for Next data

    FT800memWriteStr(RAM_CMD + cmdOffset,str)                         ; //---Sent data Text   String      
    cmdOffset = End_incCMDOffset(cmdOffset,num_cha)                   ; //Update Offset pointer Ram-CMD for End CMD-Text
     b2c:	2c 7f       	andi	r18, 0xFC	; 252
     b2e:	3f 70       	andi	r19, 0x0F	; 15
     b30:	30 93 3b 01 	sts	0x013B, r19
     b34:	20 93 3a 01 	sts	0x013A, r18
  
  }
     b38:	df 91       	pop	r29
     b3a:	cf 91       	pop	r28
     b3c:	1f 91       	pop	r17
     b3e:	0f 91       	pop	r16
     b40:	ff 90       	pop	r15
     b42:	ef 90       	pop	r14
     b44:	df 90       	pop	r13
     b46:	cf 90       	pop	r12
     b48:	bf 90       	pop	r11
     b4a:	af 90       	pop	r10
     b4c:	9f 90       	pop	r9
     b4e:	8f 90       	pop	r8
     b50:	7f 90       	pop	r7
     b52:	6f 90       	pop	r6
     b54:	08 95       	ret

00000b56 <Touch_Calibrate>:
  ++                6.3) Function-Calibrate Touch Screen                  ++
  ++                                                                      ++
  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

void Touch_Calibrate(void)
 {
     b56:	cf 92       	push	r12
     b58:	df 92       	push	r13
     b5a:	ef 92       	push	r14
     b5c:	ff 92       	push	r15
     b5e:	0f 93       	push	r16
     b60:	1f 93       	push	r17

    // Calibrate Touch Screen //

    //--- 1.Start Display List ---
   Start_CMDList(Black)    ;
     b62:	60 e0       	ldi	r22, 0x00	; 0
     b64:	70 e0       	ldi	r23, 0x00	; 0
     b66:	80 e0       	ldi	r24, 0x00	; 0
     b68:	90 e0       	ldi	r25, 0x00	; 0
     b6a:	0e 94 93 02 	call	0x526	; 0x526 <Start_CMDList>
    
    //--- 2.1 Co-Processor Draw Text-CMD --- 

   Text_CMD("Please tap on a dot",240,139,26,OPT_CENTER,White)    ;
     b6e:	80 e0       	ldi	r24, 0x00	; 0
     b70:	91 e0       	ldi	r25, 0x01	; 1
     b72:	60 ef       	ldi	r22, 0xF0	; 240
     b74:	70 e0       	ldi	r23, 0x00	; 0
     b76:	4b e8       	ldi	r20, 0x8B	; 139
     b78:	50 e0       	ldi	r21, 0x00	; 0
     b7a:	2a e1       	ldi	r18, 0x1A	; 26
     b7c:	30 e0       	ldi	r19, 0x00	; 0
     b7e:	00 e0       	ldi	r16, 0x00	; 0
     b80:	16 e0       	ldi	r17, 0x06	; 6
     b82:	ff ef       	ldi	r31, 0xFF	; 255
     b84:	cf 2e       	mov	r12, r31
     b86:	ff ef       	ldi	r31, 0xFF	; 255
     b88:	df 2e       	mov	r13, r31
     b8a:	ff ef       	ldi	r31, 0xFF	; 255
     b8c:	ef 2e       	mov	r14, r31
     b8e:	f1 2c       	mov	r15, r1
     b90:	0e 94 c0 04 	call	0x980	; 0x980 <Text_CMD>

   //--- 2.2 Co-Processor Calibrate CMD --- 

    FT800memWrite32(RAM_CMD + cmdOffset,CMD_CALIBRATE)             ; //***Sent Co-CMD for Calibrate Touch Screen
     b94:	60 91 3a 01 	lds	r22, 0x013A
     b98:	70 91 3b 01 	lds	r23, 0x013B
     b9c:	80 e0       	ldi	r24, 0x00	; 0
     b9e:	90 e0       	ldi	r25, 0x00	; 0
     ba0:	60 50       	subi	r22, 0x00	; 0
     ba2:	70 48       	sbci	r23, 0x80	; 128
     ba4:	8f 4e       	sbci	r24, 0xEF	; 239
     ba6:	9f 4f       	sbci	r25, 0xFF	; 255
     ba8:	25 e1       	ldi	r18, 0x15	; 21
     baa:	3f ef       	ldi	r19, 0xFF	; 255
     bac:	4f ef       	ldi	r20, 0xFF	; 255
     bae:	5f ef       	ldi	r21, 0xFF	; 255
     bb0:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     bb4:	20 91 3a 01 	lds	r18, 0x013A
     bb8:	30 91 3b 01 	lds	r19, 0x013B
     bbc:	c9 01       	movw	r24, r18
     bbe:	04 96       	adiw	r24, 0x04	; 4

    if(newOffset > 4095)                        //If new offset past boundary...
     bc0:	40 e1       	ldi	r20, 0x10	; 16
     bc2:	80 30       	cpi	r24, 0x00	; 0
     bc4:	94 07       	cpc	r25, r20
     bc6:	18 f0       	brcs	.+6      	; 0xbce <Touch_Calibrate+0x78>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     bc8:	c9 01       	movw	r24, r18
     bca:	8c 5f       	subi	r24, 0xFC	; 252
     bcc:	9f 40       	sbci	r25, 0x0F	; 15
   Text_CMD("Please tap on a dot",240,139,26,OPT_CENTER,White)    ;

   //--- 2.2 Co-Processor Calibrate CMD --- 

    FT800memWrite32(RAM_CMD + cmdOffset,CMD_CALIBRATE)             ; //***Sent Co-CMD for Calibrate Touch Screen
    cmdOffset = incCMDOffset(cmdOffset,4)                          ; //Update Offset pointer Ram-CMD 4 byte for Next data
     bce:	90 93 3b 01 	sts	0x013B, r25
     bd2:	80 93 3a 01 	sts	0x013A, r24


   //--- 3.End Display List and Update Execute ----

    End_CMDList();
     bd6:	0e 94 03 03 	call	0x606	; 0x606 <End_CMDList>

    Start_CMDOffset()                                              ; //Wait Calibrate Execute  
     bda:	0e 94 15 02 	call	0x42a	; 0x42a <Start_CMDOffset>


}
     bde:	1f 91       	pop	r17
     be0:	0f 91       	pop	r16
     be2:	ff 90       	pop	r15
     be4:	ef 90       	pop	r14
     be6:	df 90       	pop	r13
     be8:	cf 90       	pop	r12
     bea:	08 95       	ret

00000bec <Line_DL>:
  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/



void Line_DL(long x1,long y1,long x2,long y2,int wd,long line_color)
 {
     bec:	4f 92       	push	r4
     bee:	5f 92       	push	r5
     bf0:	6f 92       	push	r6
     bf2:	7f 92       	push	r7
     bf4:	8f 92       	push	r8
     bf6:	9f 92       	push	r9
     bf8:	af 92       	push	r10
     bfa:	bf 92       	push	r11
     bfc:	cf 92       	push	r12
     bfe:	df 92       	push	r13
     c00:	ef 92       	push	r14
     c02:	ff 92       	push	r15
     c04:	0f 93       	push	r16
     c06:	1f 93       	push	r17
     c08:	df 93       	push	r29
     c0a:	cf 93       	push	r28
     c0c:	00 d0       	rcall	.+0      	; 0xc0e <Line_DL+0x22>
     c0e:	00 d0       	rcall	.+0      	; 0xc10 <Line_DL+0x24>
     c10:	cd b7       	in	r28, 0x3d	; 61
     c12:	de b7       	in	r29, 0x3e	; 62
     c14:	2b 01       	movw	r4, r22
     c16:	3c 01       	movw	r6, r24
     c18:	29 83       	std	Y+1, r18	; 0x01
     c1a:	3a 83       	std	Y+2, r19	; 0x02
     c1c:	4b 83       	std	Y+3, r20	; 0x03
     c1e:	5c 83       	std	Y+4, r21	; 0x04
     c20:	2f 89       	ldd	r18, Y+23	; 0x17
     c22:	38 8d       	ldd	r19, Y+24	; 0x18
     c24:	49 8d       	ldd	r20, Y+25	; 0x19
     c26:	5a 8d       	ldd	r21, Y+26	; 0x1a



    //Set Attribute Line//

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_COLOR_RGB | line_color))    ; //***Sent DL-CMD Set Color Line
     c28:	60 91 3a 01 	lds	r22, 0x013A
     c2c:	70 91 3b 01 	lds	r23, 0x013B
     c30:	80 e0       	ldi	r24, 0x00	; 0
     c32:	90 e0       	ldi	r25, 0x00	; 0
     c34:	60 50       	subi	r22, 0x00	; 0
     c36:	70 48       	sbci	r23, 0x80	; 128
     c38:	8f 4e       	sbci	r24, 0xEF	; 239
     c3a:	9f 4f       	sbci	r25, 0xFF	; 255
     c3c:	54 60       	ori	r21, 0x04	; 4
     c3e:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     c42:	80 91 3a 01 	lds	r24, 0x013A
     c46:	90 91 3b 01 	lds	r25, 0x013B
     c4a:	bc 01       	movw	r22, r24
     c4c:	6c 5f       	subi	r22, 0xFC	; 252
     c4e:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     c50:	20 e1       	ldi	r18, 0x10	; 16
     c52:	60 30       	cpi	r22, 0x00	; 0
     c54:	72 07       	cpc	r23, r18
     c56:	18 f0       	brcs	.+6      	; 0xc5e <Line_DL+0x72>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     c58:	bc 01       	movw	r22, r24
     c5a:	6c 5f       	subi	r22, 0xFC	; 252
     c5c:	7f 40       	sbci	r23, 0x0F	; 15


    //Set Attribute Line//

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_COLOR_RGB | line_color))    ; //***Sent DL-CMD Set Color Line
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
     c5e:	70 93 3b 01 	sts	0x013B, r23
     c62:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_LINE_WIDTH | (wd*16)))      ; //***Sent DL-CMD Set Width Line(unit  1/16 )
     c66:	80 e0       	ldi	r24, 0x00	; 0
     c68:	90 e0       	ldi	r25, 0x00	; 0
     c6a:	60 50       	subi	r22, 0x00	; 0
     c6c:	70 48       	sbci	r23, 0x80	; 128
     c6e:	8f 4e       	sbci	r24, 0xEF	; 239
     c70:	9f 4f       	sbci	r25, 0xFF	; 255
     c72:	a4 e0       	ldi	r26, 0x04	; 4
     c74:	88 0c       	add	r8, r8
     c76:	99 1c       	adc	r9, r9
     c78:	aa 95       	dec	r26
     c7a:	e1 f7       	brne	.-8      	; 0xc74 <Line_DL+0x88>
     c7c:	94 01       	movw	r18, r8
     c7e:	44 27       	eor	r20, r20
     c80:	37 fd       	sbrc	r19, 7
     c82:	40 95       	com	r20
     c84:	54 2f       	mov	r21, r20
     c86:	5e 60       	ori	r21, 0x0E	; 14
     c88:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     c8c:	80 91 3a 01 	lds	r24, 0x013A
     c90:	90 91 3b 01 	lds	r25, 0x013B
     c94:	bc 01       	movw	r22, r24
     c96:	6c 5f       	subi	r22, 0xFC	; 252
     c98:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     c9a:	30 e1       	ldi	r19, 0x10	; 16
     c9c:	60 30       	cpi	r22, 0x00	; 0
     c9e:	73 07       	cpc	r23, r19
     ca0:	18 f0       	brcs	.+6      	; 0xca8 <Line_DL+0xbc>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     ca2:	bc 01       	movw	r22, r24
     ca4:	6c 5f       	subi	r22, 0xFC	; 252
     ca6:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_COLOR_RGB | line_color))    ; //***Sent DL-CMD Set Color Line
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_LINE_WIDTH | (wd*16)))      ; //***Sent DL-CMD Set Width Line(unit  1/16 )
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
     ca8:	70 93 3b 01 	sts	0x013B, r23
     cac:	60 93 3a 01 	sts	0x013A, r22

   //Start Draw Line//    

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_BEGIN | LINES))             ; //***Sent DL-CMD BEGIN for Line Drawing Mode
     cb0:	80 e0       	ldi	r24, 0x00	; 0
     cb2:	90 e0       	ldi	r25, 0x00	; 0
     cb4:	60 50       	subi	r22, 0x00	; 0
     cb6:	70 48       	sbci	r23, 0x80	; 128
     cb8:	8f 4e       	sbci	r24, 0xEF	; 239
     cba:	9f 4f       	sbci	r25, 0xFF	; 255
     cbc:	23 e0       	ldi	r18, 0x03	; 3
     cbe:	30 e0       	ldi	r19, 0x00	; 0
     cc0:	40 e0       	ldi	r20, 0x00	; 0
     cc2:	5f e1       	ldi	r21, 0x1F	; 31
     cc4:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     cc8:	80 91 3a 01 	lds	r24, 0x013A
     ccc:	90 91 3b 01 	lds	r25, 0x013B
     cd0:	bc 01       	movw	r22, r24
     cd2:	6c 5f       	subi	r22, 0xFC	; 252
     cd4:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     cd6:	40 e1       	ldi	r20, 0x10	; 16
     cd8:	60 30       	cpi	r22, 0x00	; 0
     cda:	74 07       	cpc	r23, r20
     cdc:	18 f0       	brcs	.+6      	; 0xce4 <Line_DL+0xf8>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     cde:	bc 01       	movw	r22, r24
     ce0:	6c 5f       	subi	r22, 0xFC	; 252
     ce2:	7f 40       	sbci	r23, 0x0F	; 15
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD

   //Start Draw Line//    

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_BEGIN | LINES))             ; //***Sent DL-CMD BEGIN for Line Drawing Mode
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
     ce4:	70 93 3b 01 	sts	0x013B, r23
     ce8:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy1))            ; //***Sent DL-CMD Set Start point Line in unit 1/16 pixel
     cec:	80 e0       	ldi	r24, 0x00	; 0
     cee:	90 e0       	ldi	r25, 0x00	; 0
     cf0:	60 50       	subi	r22, 0x00	; 0
     cf2:	70 48       	sbci	r23, 0x80	; 128
     cf4:	8f 4e       	sbci	r24, 0xEF	; 239
     cf6:	9f 4f       	sbci	r25, 0xFF	; 255
     cf8:	f3 e1       	ldi	r31, 0x13	; 19
     cfa:	44 0c       	add	r4, r4
     cfc:	55 1c       	adc	r5, r5
     cfe:	66 1c       	adc	r6, r6
     d00:	77 1c       	adc	r7, r7
     d02:	fa 95       	dec	r31
     d04:	d1 f7       	brne	.-12     	; 0xcfa <Line_DL+0x10e>
     d06:	29 81       	ldd	r18, Y+1	; 0x01
     d08:	3a 81       	ldd	r19, Y+2	; 0x02
     d0a:	4b 81       	ldd	r20, Y+3	; 0x03
     d0c:	5c 81       	ldd	r21, Y+4	; 0x04
     d0e:	e4 e0       	ldi	r30, 0x04	; 4
     d10:	22 0f       	add	r18, r18
     d12:	33 1f       	adc	r19, r19
     d14:	44 1f       	adc	r20, r20
     d16:	55 1f       	adc	r21, r21
     d18:	ea 95       	dec	r30
     d1a:	d1 f7       	brne	.-12     	; 0xd10 <Line_DL+0x124>
     d1c:	42 2a       	or	r4, r18
     d1e:	53 2a       	or	r5, r19
     d20:	64 2a       	or	r6, r20
     d22:	75 2a       	or	r7, r21
     d24:	20 e0       	ldi	r18, 0x00	; 0
     d26:	30 e0       	ldi	r19, 0x00	; 0
     d28:	40 e0       	ldi	r20, 0x00	; 0
     d2a:	50 e4       	ldi	r21, 0x40	; 64
     d2c:	42 2a       	or	r4, r18
     d2e:	53 2a       	or	r5, r19
     d30:	64 2a       	or	r6, r20
     d32:	75 2a       	or	r7, r21
     d34:	a3 01       	movw	r20, r6
     d36:	92 01       	movw	r18, r4
     d38:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     d3c:	80 91 3a 01 	lds	r24, 0x013A
     d40:	90 91 3b 01 	lds	r25, 0x013B
     d44:	bc 01       	movw	r22, r24
     d46:	6c 5f       	subi	r22, 0xFC	; 252
     d48:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     d4a:	30 e1       	ldi	r19, 0x10	; 16
     d4c:	60 30       	cpi	r22, 0x00	; 0
     d4e:	73 07       	cpc	r23, r19
     d50:	18 f0       	brcs	.+6      	; 0xd58 <Line_DL+0x16c>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     d52:	bc 01       	movw	r22, r24
     d54:	6c 5f       	subi	r22, 0xFC	; 252
     d56:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_BEGIN | LINES))             ; //***Sent DL-CMD BEGIN for Line Drawing Mode
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy1))            ; //***Sent DL-CMD Set Start point Line in unit 1/16 pixel
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
     d58:	70 93 3b 01 	sts	0x013B, r23
     d5c:	60 93 3a 01 	sts	0x013A, r22
  
    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy2))            ; //***Sent DL-CMD Set End point Line in unit 1/16 pixel
     d60:	80 e0       	ldi	r24, 0x00	; 0
     d62:	90 e0       	ldi	r25, 0x00	; 0
     d64:	60 50       	subi	r22, 0x00	; 0
     d66:	70 48       	sbci	r23, 0x80	; 128
     d68:	8f 4e       	sbci	r24, 0xEF	; 239
     d6a:	9f 4f       	sbci	r25, 0xFF	; 255
     d6c:	b3 e1       	ldi	r27, 0x13	; 19
     d6e:	ee 0c       	add	r14, r14
     d70:	ff 1c       	adc	r15, r15
     d72:	00 1f       	adc	r16, r16
     d74:	11 1f       	adc	r17, r17
     d76:	ba 95       	dec	r27
     d78:	d1 f7       	brne	.-12     	; 0xd6e <Line_DL+0x182>
     d7a:	a4 e0       	ldi	r26, 0x04	; 4
     d7c:	aa 0c       	add	r10, r10
     d7e:	bb 1c       	adc	r11, r11
     d80:	cc 1c       	adc	r12, r12
     d82:	dd 1c       	adc	r13, r13
     d84:	aa 95       	dec	r26
     d86:	d1 f7       	brne	.-12     	; 0xd7c <Line_DL+0x190>
     d88:	ea 28       	or	r14, r10
     d8a:	fb 28       	or	r15, r11
     d8c:	0c 29       	or	r16, r12
     d8e:	1d 29       	or	r17, r13
     d90:	20 e0       	ldi	r18, 0x00	; 0
     d92:	30 e0       	ldi	r19, 0x00	; 0
     d94:	40 e0       	ldi	r20, 0x00	; 0
     d96:	50 e4       	ldi	r21, 0x40	; 64
     d98:	e2 2a       	or	r14, r18
     d9a:	f3 2a       	or	r15, r19
     d9c:	04 2b       	or	r16, r20
     d9e:	15 2b       	or	r17, r21
     da0:	a8 01       	movw	r20, r16
     da2:	97 01       	movw	r18, r14
     da4:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     da8:	80 91 3a 01 	lds	r24, 0x013A
     dac:	90 91 3b 01 	lds	r25, 0x013B
     db0:	bc 01       	movw	r22, r24
     db2:	6c 5f       	subi	r22, 0xFC	; 252
     db4:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     db6:	30 e1       	ldi	r19, 0x10	; 16
     db8:	60 30       	cpi	r22, 0x00	; 0
     dba:	73 07       	cpc	r23, r19
     dbc:	18 f0       	brcs	.+6      	; 0xdc4 <Line_DL+0x1d8>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     dbe:	bc 01       	movw	r22, r24
     dc0:	6c 5f       	subi	r22, 0xFC	; 252
     dc2:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy1))            ; //***Sent DL-CMD Set Start point Line in unit 1/16 pixel
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
  
    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy2))            ; //***Sent DL-CMD Set End point Line in unit 1/16 pixel
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
     dc4:	70 93 3b 01 	sts	0x013B, r23
     dc8:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite32(RAM_CMD + cmdOffset,DL_END)                         ; //***Sent DL-CMD End Line Draw 
     dcc:	80 e0       	ldi	r24, 0x00	; 0
     dce:	90 e0       	ldi	r25, 0x00	; 0
     dd0:	60 50       	subi	r22, 0x00	; 0
     dd2:	70 48       	sbci	r23, 0x80	; 128
     dd4:	8f 4e       	sbci	r24, 0xEF	; 239
     dd6:	9f 4f       	sbci	r25, 0xFF	; 255
     dd8:	20 e0       	ldi	r18, 0x00	; 0
     dda:	30 e0       	ldi	r19, 0x00	; 0
     ddc:	40 e0       	ldi	r20, 0x00	; 0
     dde:	51 e2       	ldi	r21, 0x21	; 33
     de0:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     de4:	20 91 3a 01 	lds	r18, 0x013A
     de8:	30 91 3b 01 	lds	r19, 0x013B
     dec:	c9 01       	movw	r24, r18
     dee:	04 96       	adiw	r24, 0x04	; 4

    if(newOffset > 4095)                        //If new offset past boundary...
     df0:	40 e1       	ldi	r20, 0x10	; 16
     df2:	80 30       	cpi	r24, 0x00	; 0
     df4:	94 07       	cpc	r25, r20
     df6:	18 f0       	brcs	.+6      	; 0xdfe <Line_DL+0x212>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     df8:	c9 01       	movw	r24, r18
     dfa:	8c 5f       	subi	r24, 0xFC	; 252
     dfc:	9f 40       	sbci	r25, 0x0F	; 15
  
    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy2))            ; //***Sent DL-CMD Set End point Line in unit 1/16 pixel
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD

    FT800memWrite32(RAM_CMD + cmdOffset,DL_END)                         ; //***Sent DL-CMD End Line Draw 
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next CMD           
     dfe:	90 93 3b 01 	sts	0x013B, r25
     e02:	80 93 3a 01 	sts	0x013A, r24
  
  }
     e06:	0f 90       	pop	r0
     e08:	0f 90       	pop	r0
     e0a:	0f 90       	pop	r0
     e0c:	0f 90       	pop	r0
     e0e:	cf 91       	pop	r28
     e10:	df 91       	pop	r29
     e12:	1f 91       	pop	r17
     e14:	0f 91       	pop	r16
     e16:	ff 90       	pop	r15
     e18:	ef 90       	pop	r14
     e1a:	df 90       	pop	r13
     e1c:	cf 90       	pop	r12
     e1e:	bf 90       	pop	r11
     e20:	af 90       	pop	r10
     e22:	9f 90       	pop	r9
     e24:	8f 90       	pop	r8
     e26:	7f 90       	pop	r7
     e28:	6f 90       	pop	r6
     e2a:	5f 90       	pop	r5
     e2c:	4f 90       	pop	r4
     e2e:	08 95       	ret

00000e30 <Rect_DL>:
  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/



void Rect_DL(long x1,long y1,long x2,long y2,int wd,long rect_color)
 {
     e30:	4f 92       	push	r4
     e32:	5f 92       	push	r5
     e34:	6f 92       	push	r6
     e36:	7f 92       	push	r7
     e38:	8f 92       	push	r8
     e3a:	9f 92       	push	r9
     e3c:	af 92       	push	r10
     e3e:	bf 92       	push	r11
     e40:	cf 92       	push	r12
     e42:	df 92       	push	r13
     e44:	ef 92       	push	r14
     e46:	ff 92       	push	r15
     e48:	0f 93       	push	r16
     e4a:	1f 93       	push	r17
     e4c:	df 93       	push	r29
     e4e:	cf 93       	push	r28
     e50:	00 d0       	rcall	.+0      	; 0xe52 <Rect_DL+0x22>
     e52:	00 d0       	rcall	.+0      	; 0xe54 <Rect_DL+0x24>
     e54:	cd b7       	in	r28, 0x3d	; 61
     e56:	de b7       	in	r29, 0x3e	; 62
     e58:	2b 01       	movw	r4, r22
     e5a:	3c 01       	movw	r6, r24
     e5c:	29 83       	std	Y+1, r18	; 0x01
     e5e:	3a 83       	std	Y+2, r19	; 0x02
     e60:	4b 83       	std	Y+3, r20	; 0x03
     e62:	5c 83       	std	Y+4, r21	; 0x04
     e64:	2f 89       	ldd	r18, Y+23	; 0x17
     e66:	38 8d       	ldd	r19, Y+24	; 0x18
     e68:	49 8d       	ldd	r20, Y+25	; 0x19
     e6a:	5a 8d       	ldd	r21, Y+26	; 0x1a



    //Set Attribute Line//

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_COLOR_RGB | rect_color))    ; //***Sent DL-CMD Set Color Rectangle
     e6c:	60 91 3a 01 	lds	r22, 0x013A
     e70:	70 91 3b 01 	lds	r23, 0x013B
     e74:	80 e0       	ldi	r24, 0x00	; 0
     e76:	90 e0       	ldi	r25, 0x00	; 0
     e78:	60 50       	subi	r22, 0x00	; 0
     e7a:	70 48       	sbci	r23, 0x80	; 128
     e7c:	8f 4e       	sbci	r24, 0xEF	; 239
     e7e:	9f 4f       	sbci	r25, 0xFF	; 255
     e80:	54 60       	ori	r21, 0x04	; 4
     e82:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     e86:	80 91 3a 01 	lds	r24, 0x013A
     e8a:	90 91 3b 01 	lds	r25, 0x013B
     e8e:	bc 01       	movw	r22, r24
     e90:	6c 5f       	subi	r22, 0xFC	; 252
     e92:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     e94:	20 e1       	ldi	r18, 0x10	; 16
     e96:	60 30       	cpi	r22, 0x00	; 0
     e98:	72 07       	cpc	r23, r18
     e9a:	18 f0       	brcs	.+6      	; 0xea2 <Rect_DL+0x72>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     e9c:	bc 01       	movw	r22, r24
     e9e:	6c 5f       	subi	r22, 0xFC	; 252
     ea0:	7f 40       	sbci	r23, 0x0F	; 15


    //Set Attribute Line//

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_COLOR_RGB | rect_color))    ; //***Sent DL-CMD Set Color Rectangle
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
     ea2:	70 93 3b 01 	sts	0x013B, r23
     ea6:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_LINE_WIDTH | (wd*16)))      ; //***Sent DL-CMD Set Width Line(unit  1/16 )
     eaa:	80 e0       	ldi	r24, 0x00	; 0
     eac:	90 e0       	ldi	r25, 0x00	; 0
     eae:	60 50       	subi	r22, 0x00	; 0
     eb0:	70 48       	sbci	r23, 0x80	; 128
     eb2:	8f 4e       	sbci	r24, 0xEF	; 239
     eb4:	9f 4f       	sbci	r25, 0xFF	; 255
     eb6:	a4 e0       	ldi	r26, 0x04	; 4
     eb8:	88 0c       	add	r8, r8
     eba:	99 1c       	adc	r9, r9
     ebc:	aa 95       	dec	r26
     ebe:	e1 f7       	brne	.-8      	; 0xeb8 <Rect_DL+0x88>
     ec0:	94 01       	movw	r18, r8
     ec2:	44 27       	eor	r20, r20
     ec4:	37 fd       	sbrc	r19, 7
     ec6:	40 95       	com	r20
     ec8:	54 2f       	mov	r21, r20
     eca:	5e 60       	ori	r21, 0x0E	; 14
     ecc:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     ed0:	80 91 3a 01 	lds	r24, 0x013A
     ed4:	90 91 3b 01 	lds	r25, 0x013B
     ed8:	bc 01       	movw	r22, r24
     eda:	6c 5f       	subi	r22, 0xFC	; 252
     edc:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     ede:	30 e1       	ldi	r19, 0x10	; 16
     ee0:	60 30       	cpi	r22, 0x00	; 0
     ee2:	73 07       	cpc	r23, r19
     ee4:	18 f0       	brcs	.+6      	; 0xeec <Rect_DL+0xbc>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     ee6:	bc 01       	movw	r22, r24
     ee8:	6c 5f       	subi	r22, 0xFC	; 252
     eea:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_COLOR_RGB | rect_color))    ; //***Sent DL-CMD Set Color Rectangle
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_LINE_WIDTH | (wd*16)))      ; //***Sent DL-CMD Set Width Line(unit  1/16 )
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
     eec:	70 93 3b 01 	sts	0x013B, r23
     ef0:	60 93 3a 01 	sts	0x013A, r22

   //Start Draw Line//    

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_BEGIN | RECTS))             ; //***Sent DL-CMD BEGIN for Rectangle Drawing Mode
     ef4:	80 e0       	ldi	r24, 0x00	; 0
     ef6:	90 e0       	ldi	r25, 0x00	; 0
     ef8:	60 50       	subi	r22, 0x00	; 0
     efa:	70 48       	sbci	r23, 0x80	; 128
     efc:	8f 4e       	sbci	r24, 0xEF	; 239
     efe:	9f 4f       	sbci	r25, 0xFF	; 255
     f00:	29 e0       	ldi	r18, 0x09	; 9
     f02:	30 e0       	ldi	r19, 0x00	; 0
     f04:	40 e0       	ldi	r20, 0x00	; 0
     f06:	5f e1       	ldi	r21, 0x1F	; 31
     f08:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     f0c:	80 91 3a 01 	lds	r24, 0x013A
     f10:	90 91 3b 01 	lds	r25, 0x013B
     f14:	bc 01       	movw	r22, r24
     f16:	6c 5f       	subi	r22, 0xFC	; 252
     f18:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     f1a:	40 e1       	ldi	r20, 0x10	; 16
     f1c:	60 30       	cpi	r22, 0x00	; 0
     f1e:	74 07       	cpc	r23, r20
     f20:	18 f0       	brcs	.+6      	; 0xf28 <Rect_DL+0xf8>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     f22:	bc 01       	movw	r22, r24
     f24:	6c 5f       	subi	r22, 0xFC	; 252
     f26:	7f 40       	sbci	r23, 0x0F	; 15
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD

   //Start Draw Line//    

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_BEGIN | RECTS))             ; //***Sent DL-CMD BEGIN for Rectangle Drawing Mode
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
     f28:	70 93 3b 01 	sts	0x013B, r23
     f2c:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy1))            ; //***Sent DL-CMD Set Start point Rect in unit 1/16 pixel
     f30:	80 e0       	ldi	r24, 0x00	; 0
     f32:	90 e0       	ldi	r25, 0x00	; 0
     f34:	60 50       	subi	r22, 0x00	; 0
     f36:	70 48       	sbci	r23, 0x80	; 128
     f38:	8f 4e       	sbci	r24, 0xEF	; 239
     f3a:	9f 4f       	sbci	r25, 0xFF	; 255
     f3c:	f3 e1       	ldi	r31, 0x13	; 19
     f3e:	44 0c       	add	r4, r4
     f40:	55 1c       	adc	r5, r5
     f42:	66 1c       	adc	r6, r6
     f44:	77 1c       	adc	r7, r7
     f46:	fa 95       	dec	r31
     f48:	d1 f7       	brne	.-12     	; 0xf3e <Rect_DL+0x10e>
     f4a:	29 81       	ldd	r18, Y+1	; 0x01
     f4c:	3a 81       	ldd	r19, Y+2	; 0x02
     f4e:	4b 81       	ldd	r20, Y+3	; 0x03
     f50:	5c 81       	ldd	r21, Y+4	; 0x04
     f52:	e4 e0       	ldi	r30, 0x04	; 4
     f54:	22 0f       	add	r18, r18
     f56:	33 1f       	adc	r19, r19
     f58:	44 1f       	adc	r20, r20
     f5a:	55 1f       	adc	r21, r21
     f5c:	ea 95       	dec	r30
     f5e:	d1 f7       	brne	.-12     	; 0xf54 <Rect_DL+0x124>
     f60:	42 2a       	or	r4, r18
     f62:	53 2a       	or	r5, r19
     f64:	64 2a       	or	r6, r20
     f66:	75 2a       	or	r7, r21
     f68:	20 e0       	ldi	r18, 0x00	; 0
     f6a:	30 e0       	ldi	r19, 0x00	; 0
     f6c:	40 e0       	ldi	r20, 0x00	; 0
     f6e:	50 e4       	ldi	r21, 0x40	; 64
     f70:	42 2a       	or	r4, r18
     f72:	53 2a       	or	r5, r19
     f74:	64 2a       	or	r6, r20
     f76:	75 2a       	or	r7, r21
     f78:	a3 01       	movw	r20, r6
     f7a:	92 01       	movw	r18, r4
     f7c:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     f80:	80 91 3a 01 	lds	r24, 0x013A
     f84:	90 91 3b 01 	lds	r25, 0x013B
     f88:	bc 01       	movw	r22, r24
     f8a:	6c 5f       	subi	r22, 0xFC	; 252
     f8c:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     f8e:	30 e1       	ldi	r19, 0x10	; 16
     f90:	60 30       	cpi	r22, 0x00	; 0
     f92:	73 07       	cpc	r23, r19
     f94:	18 f0       	brcs	.+6      	; 0xf9c <Rect_DL+0x16c>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
     f96:	bc 01       	movw	r22, r24
     f98:	6c 5f       	subi	r22, 0xFC	; 252
     f9a:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_BEGIN | RECTS))             ; //***Sent DL-CMD BEGIN for Rectangle Drawing Mode
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy1))            ; //***Sent DL-CMD Set Start point Rect in unit 1/16 pixel
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
     f9c:	70 93 3b 01 	sts	0x013B, r23
     fa0:	60 93 3a 01 	sts	0x013A, r22
  
    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy2))            ; //***Sent DL-CMD Set End point Rect in unit 1/16 pixel
     fa4:	80 e0       	ldi	r24, 0x00	; 0
     fa6:	90 e0       	ldi	r25, 0x00	; 0
     fa8:	60 50       	subi	r22, 0x00	; 0
     faa:	70 48       	sbci	r23, 0x80	; 128
     fac:	8f 4e       	sbci	r24, 0xEF	; 239
     fae:	9f 4f       	sbci	r25, 0xFF	; 255
     fb0:	23 e1       	ldi	r18, 0x13	; 19
     fb2:	ee 0c       	add	r14, r14
     fb4:	ff 1c       	adc	r15, r15
     fb6:	00 1f       	adc	r16, r16
     fb8:	11 1f       	adc	r17, r17
     fba:	2a 95       	dec	r18
     fbc:	d1 f7       	brne	.-12     	; 0xfb2 <Rect_DL+0x182>
     fbe:	b4 e0       	ldi	r27, 0x04	; 4
     fc0:	aa 0c       	add	r10, r10
     fc2:	bb 1c       	adc	r11, r11
     fc4:	cc 1c       	adc	r12, r12
     fc6:	dd 1c       	adc	r13, r13
     fc8:	ba 95       	dec	r27
     fca:	d1 f7       	brne	.-12     	; 0xfc0 <Rect_DL+0x190>
     fcc:	ea 28       	or	r14, r10
     fce:	fb 28       	or	r15, r11
     fd0:	0c 29       	or	r16, r12
     fd2:	1d 29       	or	r17, r13
     fd4:	20 e0       	ldi	r18, 0x00	; 0
     fd6:	30 e0       	ldi	r19, 0x00	; 0
     fd8:	40 e0       	ldi	r20, 0x00	; 0
     fda:	50 e4       	ldi	r21, 0x40	; 64
     fdc:	e2 2a       	or	r14, r18
     fde:	f3 2a       	or	r15, r19
     fe0:	04 2b       	or	r16, r20
     fe2:	15 2b       	or	r17, r21
     fe4:	a8 01       	movw	r20, r16
     fe6:	97 01       	movw	r18, r14
     fe8:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
     fec:	80 91 3a 01 	lds	r24, 0x013A
     ff0:	90 91 3b 01 	lds	r25, 0x013B
     ff4:	bc 01       	movw	r22, r24
     ff6:	6c 5f       	subi	r22, 0xFC	; 252
     ff8:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
     ffa:	30 e1       	ldi	r19, 0x10	; 16
     ffc:	60 30       	cpi	r22, 0x00	; 0
     ffe:	73 07       	cpc	r23, r19
    1000:	18 f0       	brcs	.+6      	; 0x1008 <Rect_DL+0x1d8>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
    1002:	bc 01       	movw	r22, r24
    1004:	6c 5f       	subi	r22, 0xFC	; 252
    1006:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy1))            ; //***Sent DL-CMD Set Start point Rect in unit 1/16 pixel
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
  
    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy2))            ; //***Sent DL-CMD Set End point Rect in unit 1/16 pixel
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
    1008:	70 93 3b 01 	sts	0x013B, r23
    100c:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite32(RAM_CMD + cmdOffset,DL_END)                         ; //***Sent DL-CMD End Rectangle Draw  
    1010:	80 e0       	ldi	r24, 0x00	; 0
    1012:	90 e0       	ldi	r25, 0x00	; 0
    1014:	60 50       	subi	r22, 0x00	; 0
    1016:	70 48       	sbci	r23, 0x80	; 128
    1018:	8f 4e       	sbci	r24, 0xEF	; 239
    101a:	9f 4f       	sbci	r25, 0xFF	; 255
    101c:	20 e0       	ldi	r18, 0x00	; 0
    101e:	30 e0       	ldi	r19, 0x00	; 0
    1020:	40 e0       	ldi	r20, 0x00	; 0
    1022:	51 e2       	ldi	r21, 0x21	; 33
    1024:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
    1028:	20 91 3a 01 	lds	r18, 0x013A
    102c:	30 91 3b 01 	lds	r19, 0x013B
    1030:	c9 01       	movw	r24, r18
    1032:	04 96       	adiw	r24, 0x04	; 4

    if(newOffset > 4095)                        //If new offset past boundary...
    1034:	40 e1       	ldi	r20, 0x10	; 16
    1036:	80 30       	cpi	r24, 0x00	; 0
    1038:	94 07       	cpc	r25, r20
    103a:	18 f0       	brcs	.+6      	; 0x1042 <Rect_DL+0x212>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
    103c:	c9 01       	movw	r24, r18
    103e:	8c 5f       	subi	r24, 0xFC	; 252
    1040:	9f 40       	sbci	r25, 0x0F	; 15
  
    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy2))            ; //***Sent DL-CMD Set End point Rect in unit 1/16 pixel
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD

    FT800memWrite32(RAM_CMD + cmdOffset,DL_END)                         ; //***Sent DL-CMD End Rectangle Draw  
    cmdOffset = incCMDOffset(cmdOffset,4)                               ; //Update Offset pointer Ram-CMD 4 byte for Next CMD           
    1042:	90 93 3b 01 	sts	0x013B, r25
    1046:	80 93 3a 01 	sts	0x013A, r24
  
  }
    104a:	0f 90       	pop	r0
    104c:	0f 90       	pop	r0
    104e:	0f 90       	pop	r0
    1050:	0f 90       	pop	r0
    1052:	cf 91       	pop	r28
    1054:	df 91       	pop	r29
    1056:	1f 91       	pop	r17
    1058:	0f 91       	pop	r16
    105a:	ff 90       	pop	r15
    105c:	ef 90       	pop	r14
    105e:	df 90       	pop	r13
    1060:	cf 90       	pop	r12
    1062:	bf 90       	pop	r11
    1064:	af 90       	pop	r10
    1066:	9f 90       	pop	r9
    1068:	8f 90       	pop	r8
    106a:	7f 90       	pop	r7
    106c:	6f 90       	pop	r6
    106e:	5f 90       	pop	r5
    1070:	4f 90       	pop	r4
    1072:	08 95       	ret

00001074 <Point_DL>:
  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/



void Point_DL(long x,long y,int point_size,long point_color)
 {
    1074:	4f 92       	push	r4
    1076:	5f 92       	push	r5
    1078:	6f 92       	push	r6
    107a:	7f 92       	push	r7
    107c:	8f 92       	push	r8
    107e:	9f 92       	push	r9
    1080:	af 92       	push	r10
    1082:	bf 92       	push	r11
    1084:	cf 92       	push	r12
    1086:	df 92       	push	r13
    1088:	ef 92       	push	r14
    108a:	ff 92       	push	r15
    108c:	0f 93       	push	r16
    108e:	1f 93       	push	r17
    1090:	4b 01       	movw	r8, r22
    1092:	5c 01       	movw	r10, r24
    1094:	29 01       	movw	r4, r18
    1096:	3a 01       	movw	r6, r20
    1098:	a7 01       	movw	r20, r14
    109a:	96 01       	movw	r18, r12
    xy = x|y        ;


    //Set Attribute Line//

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_COLOR_RGB | point_color))      ; //***Sent DL-CMD Set Color Point
    109c:	60 91 3a 01 	lds	r22, 0x013A
    10a0:	70 91 3b 01 	lds	r23, 0x013B
    10a4:	80 e0       	ldi	r24, 0x00	; 0
    10a6:	90 e0       	ldi	r25, 0x00	; 0
    10a8:	60 50       	subi	r22, 0x00	; 0
    10aa:	70 48       	sbci	r23, 0x80	; 128
    10ac:	8f 4e       	sbci	r24, 0xEF	; 239
    10ae:	9f 4f       	sbci	r25, 0xFF	; 255
    10b0:	54 60       	ori	r21, 0x04	; 4
    10b2:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
    10b6:	80 91 3a 01 	lds	r24, 0x013A
    10ba:	90 91 3b 01 	lds	r25, 0x013B
    10be:	bc 01       	movw	r22, r24
    10c0:	6c 5f       	subi	r22, 0xFC	; 252
    10c2:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
    10c4:	20 e1       	ldi	r18, 0x10	; 16
    10c6:	60 30       	cpi	r22, 0x00	; 0
    10c8:	72 07       	cpc	r23, r18
    10ca:	18 f0       	brcs	.+6      	; 0x10d2 <Point_DL+0x5e>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
    10cc:	bc 01       	movw	r22, r24
    10ce:	6c 5f       	subi	r22, 0xFC	; 252
    10d0:	7f 40       	sbci	r23, 0x0F	; 15


    //Set Attribute Line//

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_COLOR_RGB | point_color))      ; //***Sent DL-CMD Set Color Point
    cmdOffset = incCMDOffset(cmdOffset,4)                                  ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
    10d2:	70 93 3b 01 	sts	0x013B, r23
    10d6:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_POINT_SIZE | (point_size*16))) ; //***Sent DL-CMD Set Point Size (unit 1/16 )
    10da:	80 e0       	ldi	r24, 0x00	; 0
    10dc:	90 e0       	ldi	r25, 0x00	; 0
    10de:	60 50       	subi	r22, 0x00	; 0
    10e0:	70 48       	sbci	r23, 0x80	; 128
    10e2:	8f 4e       	sbci	r24, 0xEF	; 239
    10e4:	9f 4f       	sbci	r25, 0xFF	; 255
    10e6:	24 e0       	ldi	r18, 0x04	; 4
    10e8:	00 0f       	add	r16, r16
    10ea:	11 1f       	adc	r17, r17
    10ec:	2a 95       	dec	r18
    10ee:	e1 f7       	brne	.-8      	; 0x10e8 <Point_DL+0x74>
    10f0:	98 01       	movw	r18, r16
    10f2:	44 27       	eor	r20, r20
    10f4:	37 fd       	sbrc	r19, 7
    10f6:	40 95       	com	r20
    10f8:	54 2f       	mov	r21, r20
    10fa:	5d 60       	ori	r21, 0x0D	; 13
    10fc:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
    1100:	80 91 3a 01 	lds	r24, 0x013A
    1104:	90 91 3b 01 	lds	r25, 0x013B
    1108:	bc 01       	movw	r22, r24
    110a:	6c 5f       	subi	r22, 0xFC	; 252
    110c:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
    110e:	30 e1       	ldi	r19, 0x10	; 16
    1110:	60 30       	cpi	r22, 0x00	; 0
    1112:	73 07       	cpc	r23, r19
    1114:	18 f0       	brcs	.+6      	; 0x111c <__stack+0x1d>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
    1116:	bc 01       	movw	r22, r24
    1118:	6c 5f       	subi	r22, 0xFC	; 252
    111a:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_COLOR_RGB | point_color))      ; //***Sent DL-CMD Set Color Point
    cmdOffset = incCMDOffset(cmdOffset,4)                                  ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_POINT_SIZE | (point_size*16))) ; //***Sent DL-CMD Set Point Size (unit 1/16 )
    cmdOffset = incCMDOffset(cmdOffset,4)                                  ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
    111c:	70 93 3b 01 	sts	0x013B, r23
    1120:	60 93 3a 01 	sts	0x013A, r22

   //Start Draw Line//    

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_BEGIN | FTPOINTS ))            ; //***Sent DL-CMD BEGIN for Point Drawing Mode
    1124:	80 e0       	ldi	r24, 0x00	; 0
    1126:	90 e0       	ldi	r25, 0x00	; 0
    1128:	60 50       	subi	r22, 0x00	; 0
    112a:	70 48       	sbci	r23, 0x80	; 128
    112c:	8f 4e       	sbci	r24, 0xEF	; 239
    112e:	9f 4f       	sbci	r25, 0xFF	; 255
    1130:	22 e0       	ldi	r18, 0x02	; 2
    1132:	30 e0       	ldi	r19, 0x00	; 0
    1134:	40 e0       	ldi	r20, 0x00	; 0
    1136:	5f e1       	ldi	r21, 0x1F	; 31
    1138:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
    113c:	80 91 3a 01 	lds	r24, 0x013A
    1140:	90 91 3b 01 	lds	r25, 0x013B
    1144:	bc 01       	movw	r22, r24
    1146:	6c 5f       	subi	r22, 0xFC	; 252
    1148:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
    114a:	40 e1       	ldi	r20, 0x10	; 16
    114c:	60 30       	cpi	r22, 0x00	; 0
    114e:	74 07       	cpc	r23, r20
    1150:	18 f0       	brcs	.+6      	; 0x1158 <__stack+0x59>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
    1152:	bc 01       	movw	r22, r24
    1154:	6c 5f       	subi	r22, 0xFC	; 252
    1156:	7f 40       	sbci	r23, 0x0F	; 15
    cmdOffset = incCMDOffset(cmdOffset,4)                                  ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD

   //Start Draw Line//    

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_BEGIN | FTPOINTS ))            ; //***Sent DL-CMD BEGIN for Point Drawing Mode
    cmdOffset = incCMDOffset(cmdOffset,4)                                  ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
    1158:	70 93 3b 01 	sts	0x013B, r23
    115c:	60 93 3a 01 	sts	0x013A, r22

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy))                ; //***Sent DL-CMD Set Position  point in unit 1/16 pixel
    1160:	80 e0       	ldi	r24, 0x00	; 0
    1162:	90 e0       	ldi	r25, 0x00	; 0
    1164:	60 50       	subi	r22, 0x00	; 0
    1166:	70 48       	sbci	r23, 0x80	; 128
    1168:	8f 4e       	sbci	r24, 0xEF	; 239
    116a:	9f 4f       	sbci	r25, 0xFF	; 255
    116c:	13 e1       	ldi	r17, 0x13	; 19
    116e:	88 0c       	add	r8, r8
    1170:	99 1c       	adc	r9, r9
    1172:	aa 1c       	adc	r10, r10
    1174:	bb 1c       	adc	r11, r11
    1176:	1a 95       	dec	r17
    1178:	d1 f7       	brne	.-12     	; 0x116e <__stack+0x6f>
    117a:	b4 e0       	ldi	r27, 0x04	; 4
    117c:	44 0c       	add	r4, r4
    117e:	55 1c       	adc	r5, r5
    1180:	66 1c       	adc	r6, r6
    1182:	77 1c       	adc	r7, r7
    1184:	ba 95       	dec	r27
    1186:	d1 f7       	brne	.-12     	; 0x117c <__stack+0x7d>
    1188:	84 28       	or	r8, r4
    118a:	95 28       	or	r9, r5
    118c:	a6 28       	or	r10, r6
    118e:	b7 28       	or	r11, r7
    1190:	20 e0       	ldi	r18, 0x00	; 0
    1192:	30 e0       	ldi	r19, 0x00	; 0
    1194:	40 e0       	ldi	r20, 0x00	; 0
    1196:	50 e4       	ldi	r21, 0x40	; 64
    1198:	82 2a       	or	r8, r18
    119a:	93 2a       	or	r9, r19
    119c:	a4 2a       	or	r10, r20
    119e:	b5 2a       	or	r11, r21
    11a0:	a5 01       	movw	r20, r10
    11a2:	94 01       	movw	r18, r8
    11a4:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
    11a8:	80 91 3a 01 	lds	r24, 0x013A
    11ac:	90 91 3b 01 	lds	r25, 0x013B
    11b0:	bc 01       	movw	r22, r24
    11b2:	6c 5f       	subi	r22, 0xFC	; 252
    11b4:	7f 4f       	sbci	r23, 0xFF	; 255

    if(newOffset > 4095)                        //If new offset past boundary...
    11b6:	30 e1       	ldi	r19, 0x10	; 16
    11b8:	60 30       	cpi	r22, 0x00	; 0
    11ba:	73 07       	cpc	r23, r19
    11bc:	18 f0       	brcs	.+6      	; 0x11c4 <__stack+0xc5>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
    11be:	bc 01       	movw	r22, r24
    11c0:	6c 5f       	subi	r22, 0xFC	; 252
    11c2:	7f 40       	sbci	r23, 0x0F	; 15

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_BEGIN | FTPOINTS ))            ; //***Sent DL-CMD BEGIN for Point Drawing Mode
    cmdOffset = incCMDOffset(cmdOffset,4)                                  ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD

    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy))                ; //***Sent DL-CMD Set Position  point in unit 1/16 pixel
    cmdOffset = incCMDOffset(cmdOffset,4)                                  ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
    11c4:	70 93 3b 01 	sts	0x013B, r23
    11c8:	60 93 3a 01 	sts	0x013A, r22
  

    FT800memWrite32(RAM_CMD + cmdOffset,DL_END)                            ; //***Sent DL-CMD End Point Draw  
    11cc:	80 e0       	ldi	r24, 0x00	; 0
    11ce:	90 e0       	ldi	r25, 0x00	; 0
    11d0:	60 50       	subi	r22, 0x00	; 0
    11d2:	70 48       	sbci	r23, 0x80	; 128
    11d4:	8f 4e       	sbci	r24, 0xEF	; 239
    11d6:	9f 4f       	sbci	r25, 0xFF	; 255
    11d8:	20 e0       	ldi	r18, 0x00	; 0
    11da:	30 e0       	ldi	r19, 0x00	; 0
    11dc:	40 e0       	ldi	r20, 0x00	; 0
    11de:	51 e2       	ldi	r21, 0x21	; 33
    11e0:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

unsigned int incCMDOffset(unsigned int currentOffset, unsigned char commandSize)
{
    unsigned int newOffset                  ;   //used to hold new offset

    newOffset = currentOffset + commandSize ;   //Calculate new offset
    11e4:	20 91 3a 01 	lds	r18, 0x013A
    11e8:	30 91 3b 01 	lds	r19, 0x013B
    11ec:	c9 01       	movw	r24, r18
    11ee:	04 96       	adiw	r24, 0x04	; 4

    if(newOffset > 4095)                        //If new offset past boundary...
    11f0:	40 e1       	ldi	r20, 0x10	; 16
    11f2:	80 30       	cpi	r24, 0x00	; 0
    11f4:	94 07       	cpc	r25, r20
    11f6:	18 f0       	brcs	.+6      	; 0x11fe <__stack+0xff>
    {
        newOffset = (newOffset - 4096)      ;   //... roll over pointer
    11f8:	c9 01       	movw	r24, r18
    11fa:	8c 5f       	subi	r24, 0xFC	; 252
    11fc:	9f 40       	sbci	r25, 0x0F	; 15
    FT800memWrite32(RAM_CMD + cmdOffset,(DL_VERTEX2F | xy))                ; //***Sent DL-CMD Set Position  point in unit 1/16 pixel
    cmdOffset = incCMDOffset(cmdOffset,4)                                  ; //Update Offset pointer Ram-CMD 4 byte for Next DL-CMD
  

    FT800memWrite32(RAM_CMD + cmdOffset,DL_END)                            ; //***Sent DL-CMD End Point Draw  
    cmdOffset = incCMDOffset(cmdOffset,4)                                  ; //Update Offset pointer Ram-CMD 4 byte for Next CMD           
    11fe:	90 93 3b 01 	sts	0x013B, r25
    1202:	80 93 3a 01 	sts	0x013A, r24
  
  }
    1206:	1f 91       	pop	r17
    1208:	0f 91       	pop	r16
    120a:	ff 90       	pop	r15
    120c:	ef 90       	pop	r14
    120e:	df 90       	pop	r13
    1210:	cf 90       	pop	r12
    1212:	bf 90       	pop	r11
    1214:	af 90       	pop	r10
    1216:	9f 90       	pop	r9
    1218:	8f 90       	pop	r8
    121a:	7f 90       	pop	r7
    121c:	6f 90       	pop	r6
    121e:	5f 90       	pop	r5
    1220:	4f 90       	pop	r4
    1222:	08 95       	ret

00001224 <FT800_Initial>:
  ++                                                                   ++                                       
  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/


void FT800_Initial(void)         
 {
    1224:	1f 93       	push	r17
    1226:	cf 93       	push	r28
    1228:	df 93       	push	r29
}


void FT800_PD_lo(void)
{
    cbi(PORTB,4)       ;   //PB4=0:Enable Power-Down FT800
    122a:	c4 98       	cbi	0x18, 4	; 24
    122c:	84 e1       	ldi	r24, 0x14	; 20
    122e:	90 e0       	ldi	r25, 0x00	; 0
    1230:	20 ea       	ldi	r18, 0xA0	; 160
    1232:	3f e0       	ldi	r19, 0x0F	; 15
    1234:	f9 01       	movw	r30, r18
    1236:	31 97       	sbiw	r30, 0x01	; 1
    1238:	f1 f7       	brne	.-4      	; 0x1236 <FT800_Initial+0x12>
 ++                                                ++
 +++++++++++++++++++++++++++++++++++++++++++++++++++*/

 void delay_ms(unsigned int cnt)
  {
    for(;cnt>0;cnt--)
    123a:	01 97       	sbiw	r24, 0x01	; 1
    123c:	d9 f7       	brne	.-10     	; 0x1234 <FT800_Initial+0x10>
  ++                                                                         ++
  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

void FT800_PD_hi(void)
{
   sbi(PORTB,4)       ;   //PB4=1:Disable Power-Down FT800
    123e:	c4 9a       	sbi	0x18, 4	; 24
    1240:	24 e1       	ldi	r18, 0x14	; 20
    1242:	30 e0       	ldi	r19, 0x00	; 0
    1244:	40 ea       	ldi	r20, 0xA0	; 160
    1246:	5f e0       	ldi	r21, 0x0F	; 15
    1248:	c0 ea       	ldi	r28, 0xA0	; 160
    124a:	df e0       	ldi	r29, 0x0F	; 15
    124c:	ca 01       	movw	r24, r20
    124e:	01 97       	sbiw	r24, 0x01	; 1
    1250:	f1 f7       	brne	.-4      	; 0x124e <FT800_Initial+0x2a>
 ++                                                ++
 +++++++++++++++++++++++++++++++++++++++++++++++++++*/

 void delay_ms(unsigned int cnt)
  {
    for(;cnt>0;cnt--)
    1252:	21 50       	subi	r18, 0x01	; 1
    1254:	30 40       	sbci	r19, 0x00	; 0
    1256:	c1 f7       	brne	.-16     	; 0x1248 <FT800_Initial+0x24>
    
   FT800_PD_hi()                            ;  //Power-Up FT800  
   delay_ms(20)                             ;  //delay 20 ms


   FT800_HostCmdWrite(FT800_ACTIVE)         ;  //***Sent Host-CMD Start FT800
    1258:	80 e0       	ldi	r24, 0x00	; 0
    125a:	0e 94 5a 01 	call	0x2b4	; 0x2b4 <FT800_HostCmdWrite>
    125e:	ce 01       	movw	r24, r28
    1260:	01 97       	sbiw	r24, 0x01	; 1
    1262:	f1 f7       	brne	.-4      	; 0x1260 <FT800_Initial+0x3c>
    1264:	ce 01       	movw	r24, r28
    1266:	01 97       	sbiw	r24, 0x01	; 1
    1268:	f1 f7       	brne	.-4      	; 0x1266 <FT800_Initial+0x42>
    126a:	ce 01       	movw	r24, r28
    126c:	01 97       	sbiw	r24, 0x01	; 1
    126e:	f1 f7       	brne	.-4      	; 0x126c <FT800_Initial+0x48>
    1270:	ce 01       	movw	r24, r28
    1272:	01 97       	sbiw	r24, 0x01	; 1
    1274:	f1 f7       	brne	.-4      	; 0x1272 <FT800_Initial+0x4e>
    1276:	ce 01       	movw	r24, r28
    1278:	01 97       	sbiw	r24, 0x01	; 1
    127a:	f1 f7       	brne	.-4      	; 0x1278 <FT800_Initial+0x54>
   delay_ms(5);                                //Give some time to process

   FT800_HostCmdWrite(FT800_CLKEXT)         ;  //***Sent Host-CMD Set FT800 for external clock
    127c:	84 e4       	ldi	r24, 0x44	; 68
    127e:	0e 94 5a 01 	call	0x2b4	; 0x2b4 <FT800_HostCmdWrite>
    1282:	ce 01       	movw	r24, r28
    1284:	01 97       	sbiw	r24, 0x01	; 1
    1286:	f1 f7       	brne	.-4      	; 0x1284 <FT800_Initial+0x60>
    1288:	ce 01       	movw	r24, r28
    128a:	01 97       	sbiw	r24, 0x01	; 1
    128c:	f1 f7       	brne	.-4      	; 0x128a <FT800_Initial+0x66>
    128e:	ce 01       	movw	r24, r28
    1290:	01 97       	sbiw	r24, 0x01	; 1
    1292:	f1 f7       	brne	.-4      	; 0x1290 <FT800_Initial+0x6c>
    1294:	ce 01       	movw	r24, r28
    1296:	01 97       	sbiw	r24, 0x01	; 1
    1298:	f1 f7       	brne	.-4      	; 0x1296 <FT800_Initial+0x72>
    129a:	ce 01       	movw	r24, r28
    129c:	01 97       	sbiw	r24, 0x01	; 1
    129e:	f1 f7       	brne	.-4      	; 0x129c <FT800_Initial+0x78>
   delay_ms(5);                                //Give some time to process

   FT800_HostCmdWrite(FT800_CLK48M)         ;  //***Sent Host-CMD Set FT800 for 48MHz PLL
    12a0:	82 e6       	ldi	r24, 0x62	; 98
    12a2:	0e 94 5a 01 	call	0x2b4	; 0x2b4 <FT800_HostCmdWrite>
    12a6:	ce 01       	movw	r24, r28
    12a8:	01 97       	sbiw	r24, 0x01	; 1
    12aa:	f1 f7       	brne	.-4      	; 0x12a8 <FT800_Initial+0x84>
    12ac:	ce 01       	movw	r24, r28
    12ae:	01 97       	sbiw	r24, 0x01	; 1
    12b0:	f1 f7       	brne	.-4      	; 0x12ae <FT800_Initial+0x8a>
    12b2:	ce 01       	movw	r24, r28
    12b4:	01 97       	sbiw	r24, 0x01	; 1
    12b6:	f1 f7       	brne	.-4      	; 0x12b4 <FT800_Initial+0x90>
    12b8:	ce 01       	movw	r24, r28
    12ba:	01 97       	sbiw	r24, 0x01	; 1
    12bc:	f1 f7       	brne	.-4      	; 0x12ba <FT800_Initial+0x96>
    12be:	ce 01       	movw	r24, r28
    12c0:	01 97       	sbiw	r24, 0x01	; 1
    12c2:	f1 f7       	brne	.-4      	; 0x12c0 <FT800_Initial+0x9c>
   delay_ms(5)                              ;  //Give some time to process
                                               //Now FT800 can accept commands at up to 30MHz clock on SPI bus
                                               //This application leaves the SPI bus at 4MHz

  if(FT800memRead8(REG_ID) != 0x7C)            //***Read ID register - is it 0x7C?
    12c4:	60 e0       	ldi	r22, 0x00	; 0
    12c6:	74 e2       	ldi	r23, 0x24	; 36
    12c8:	80 e1       	ldi	r24, 0x10	; 16
    12ca:	90 e0       	ldi	r25, 0x00	; 0
    12cc:	0e 94 65 01 	call	0x2ca	; 0x2ca <FT800memRead8>
    12d0:	8c 37       	cpi	r24, 0x7C	; 124
    12d2:	09 f0       	breq	.+2      	; 0x12d6 <FT800_Initial+0xb2>
    12d4:	ff cf       	rjmp	.-2      	; 0x12d4 <FT800_Initial+0xb0>
   {
   
     while(1);                                 //If we don't get 0x7C, the ineface isn't working - halt with infinite loop
   }  
  
   FT800memWrite8(REG_PCLK,ZERO)           ;   //***Write data zero to Reg.PCLK  for don't clock the LCD until later
    12d6:	6c e6       	ldi	r22, 0x6C	; 108
    12d8:	74 e2       	ldi	r23, 0x24	; 36
    12da:	80 e1       	ldi	r24, 0x10	; 16
    12dc:	90 e0       	ldi	r25, 0x00	; 0
    12de:	40 e0       	ldi	r20, 0x00	; 0
    12e0:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>
   FT800memWrite8(REG_PWM_DUTY,ZERO)       ;   //***Write data zero to Reg.PWM_Duty for Turn off backlight
    12e4:	64 ec       	ldi	r22, 0xC4	; 196
    12e6:	74 e2       	ldi	r23, 0x24	; 36
    12e8:	80 e1       	ldi	r24, 0x10	; 16
    12ea:	90 e0       	ldi	r25, 0x00	; 0
    12ec:	40 e0       	ldi	r20, 0x00	; 0
    12ee:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>
  


 //-------------------- 2.Configure Display ------------------------

  FT800memWrite16(REG_HSIZE,480)           ;  //***Write data to Reg : Active display width =480 Pixel
    12f2:	60 e3       	ldi	r22, 0x30	; 48
    12f4:	74 e2       	ldi	r23, 0x24	; 36
    12f6:	80 e1       	ldi	r24, 0x10	; 16
    12f8:	90 e0       	ldi	r25, 0x00	; 0
    12fa:	40 ee       	ldi	r20, 0xE0	; 224
    12fc:	51 e0       	ldi	r21, 0x01	; 1
    12fe:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>
  FT800memWrite16(REG_HCYCLE,548)          ;  //***Write data to Reg : Total number of clocks per line, incl front/back porch
    1302:	68 e2       	ldi	r22, 0x28	; 40
    1304:	74 e2       	ldi	r23, 0x24	; 36
    1306:	80 e1       	ldi	r24, 0x10	; 16
    1308:	90 e0       	ldi	r25, 0x00	; 0
    130a:	44 e2       	ldi	r20, 0x24	; 36
    130c:	52 e0       	ldi	r21, 0x02	; 2
    130e:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>
  FT800memWrite16(REG_HOFFSET,43)          ;  //***Write data to Reg : start of active line
    1312:	6c e2       	ldi	r22, 0x2C	; 44
    1314:	74 e2       	ldi	r23, 0x24	; 36
    1316:	80 e1       	ldi	r24, 0x10	; 16
    1318:	90 e0       	ldi	r25, 0x00	; 0
    131a:	4b e2       	ldi	r20, 0x2B	; 43
    131c:	50 e0       	ldi	r21, 0x00	; 0
    131e:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>
  FT800memWrite16(REG_HSYNC0,0)            ;  //***Write data to Reg : Start of horizontal sync pulse
    1322:	64 e3       	ldi	r22, 0x34	; 52
    1324:	74 e2       	ldi	r23, 0x24	; 36
    1326:	80 e1       	ldi	r24, 0x10	; 16
    1328:	90 e0       	ldi	r25, 0x00	; 0
    132a:	40 e0       	ldi	r20, 0x00	; 0
    132c:	50 e0       	ldi	r21, 0x00	; 0
    132e:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>
  FT800memWrite16(REG_HSYNC1,41)           ;  //***Write data to Reg : End of horizontal sync pulse
    1332:	68 e3       	ldi	r22, 0x38	; 56
    1334:	74 e2       	ldi	r23, 0x24	; 36
    1336:	80 e1       	ldi	r24, 0x10	; 16
    1338:	90 e0       	ldi	r25, 0x00	; 0
    133a:	49 e2       	ldi	r20, 0x29	; 41
    133c:	50 e0       	ldi	r21, 0x00	; 0
    133e:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>
  
  FT800memWrite16(REG_VSIZE,272)           ;  //***Write data to Reg : Active display height =272 Pixel
    1342:	64 e4       	ldi	r22, 0x44	; 68
    1344:	74 e2       	ldi	r23, 0x24	; 36
    1346:	80 e1       	ldi	r24, 0x10	; 16
    1348:	90 e0       	ldi	r25, 0x00	; 0
    134a:	40 e1       	ldi	r20, 0x10	; 16
    134c:	51 e0       	ldi	r21, 0x01	; 1
    134e:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>
  FT800memWrite16(REG_VCYCLE,292)          ;  //***Write data to Reg : Total number of lines per screen, incl pre/post
    1352:	6c e3       	ldi	r22, 0x3C	; 60
    1354:	74 e2       	ldi	r23, 0x24	; 36
    1356:	80 e1       	ldi	r24, 0x10	; 16
    1358:	90 e0       	ldi	r25, 0x00	; 0
    135a:	44 e2       	ldi	r20, 0x24	; 36
    135c:	51 e0       	ldi	r21, 0x01	; 1
    135e:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>
  FT800memWrite16(REG_VOFFSET,12)          ;  //***Write data to Reg : Start of active screen
    1362:	60 e4       	ldi	r22, 0x40	; 64
    1364:	74 e2       	ldi	r23, 0x24	; 36
    1366:	80 e1       	ldi	r24, 0x10	; 16
    1368:	90 e0       	ldi	r25, 0x00	; 0
    136a:	4c e0       	ldi	r20, 0x0C	; 12
    136c:	50 e0       	ldi	r21, 0x00	; 0
    136e:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>
  FT800memWrite16(REG_VSYNC0,0)            ;  //***Write data to Reg : Start of vertical sync pulse
    1372:	68 e4       	ldi	r22, 0x48	; 72
    1374:	74 e2       	ldi	r23, 0x24	; 36
    1376:	80 e1       	ldi	r24, 0x10	; 16
    1378:	90 e0       	ldi	r25, 0x00	; 0
    137a:	40 e0       	ldi	r20, 0x00	; 0
    137c:	50 e0       	ldi	r21, 0x00	; 0
    137e:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>
  FT800memWrite16(REG_VSYNC1,10)           ;  //***Write data to Reg : End of vertical sync pulse
    1382:	6c e4       	ldi	r22, 0x4C	; 76
    1384:	74 e2       	ldi	r23, 0x24	; 36
    1386:	80 e1       	ldi	r24, 0x10	; 16
    1388:	90 e0       	ldi	r25, 0x00	; 0
    138a:	4a e0       	ldi	r20, 0x0A	; 10
    138c:	50 e0       	ldi	r21, 0x00	; 0
    138e:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>
  
  FT800memWrite8(REG_SWIZZLE,0)            ;  //***Write data to Reg : FT800 output to LCD - pin order
    1392:	60 e6       	ldi	r22, 0x60	; 96
    1394:	74 e2       	ldi	r23, 0x24	; 36
    1396:	80 e1       	ldi	r24, 0x10	; 16
    1398:	90 e0       	ldi	r25, 0x00	; 0
    139a:	40 e0       	ldi	r20, 0x00	; 0
    139c:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>
  FT800memWrite8(REG_PCLK_POL,1)           ;  //***Write data to Reg : LCD data is clocked in on this PCLK edge
    13a0:	68 e6       	ldi	r22, 0x68	; 104
    13a2:	74 e2       	ldi	r23, 0x24	; 36
    13a4:	80 e1       	ldi	r24, 0x10	; 16
    13a6:	90 e0       	ldi	r25, 0x00	; 0
    13a8:	41 e0       	ldi	r20, 0x01	; 1
    13aa:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>
                                              //***Write data to Reg : Don't set PCLK yet - wait for just after the first display list


 //------------------- 3.Configure Touch -----------------
  
  FT800memWrite8(REG_TOUCH_MODE,0x03)      ;  //***Write data to Reg : Touch Mode Continuous
    13ae:	60 ef       	ldi	r22, 0xF0	; 240
    13b0:	74 e2       	ldi	r23, 0x24	; 36
    13b2:	80 e1       	ldi	r24, 0x10	; 16
    13b4:	90 e0       	ldi	r25, 0x00	; 0
    13b6:	43 e0       	ldi	r20, 0x03	; 3
    13b8:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>
  FT800memWrite16(REG_TOUCH_RZTHRESH,1200) ;  //***Write data to Reg : Eliminate any false touches
    13bc:	64 e0       	ldi	r22, 0x04	; 4
    13be:	75 e2       	ldi	r23, 0x25	; 37
    13c0:	80 e1       	ldi	r24, 0x10	; 16
    13c2:	90 e0       	ldi	r25, 0x00	; 0
    13c4:	40 eb       	ldi	r20, 0xB0	; 176
    13c6:	54 e0       	ldi	r21, 0x04	; 4
    13c8:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>
  

//-------------------- 4. Configure Audio ----------------


  FT800memWrite8(REG_GPIO_DIR,0x082)        ;   //***Write Data to Reg :  Set Direction  GPIO 7,1 = Output
    13cc:	6c e8       	ldi	r22, 0x8C	; 140
    13ce:	74 e2       	ldi	r23, 0x24	; 36
    13d0:	80 e1       	ldi	r24, 0x10	; 16
    13d2:	90 e0       	ldi	r25, 0x00	; 0
    13d4:	42 e8       	ldi	r20, 0x82	; 130
    13d6:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>

  ft800Gpio = FT800memRead8(REG_GPIO)      ;   //***Read the FT800 GPIO register for a read/modify/write operation
    13da:	60 e9       	ldi	r22, 0x90	; 144
    13dc:	74 e2       	ldi	r23, 0x24	; 36
    13de:	80 e1       	ldi	r24, 0x10	; 16
    13e0:	90 e0       	ldi	r25, 0x00	; 0
    13e2:	0e 94 65 01 	call	0x2ca	; 0x2ca <FT800memRead8>
  ft800Gpio = ft800Gpio | 0x02             ;   //set bit 1 of FT800 GPIO register (Audio) - others are inputs
    13e6:	48 2f       	mov	r20, r24
    13e8:	42 60       	ori	r20, 0x02	; 2
    13ea:	40 93 40 01 	sts	0x0140, r20

  FT800memWrite8(REG_GPIO,ft800Gpio)       ;   //***Write Data to Reg : Enable(1) the Audio Amp
    13ee:	60 e9       	ldi	r22, 0x90	; 144
    13f0:	74 e2       	ldi	r23, 0x24	; 36
    13f2:	80 e1       	ldi	r24, 0x10	; 16
    13f4:	90 e0       	ldi	r25, 0x00	; 0
    13f6:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>
  
  FT800memWrite8(REG_VOL_PB,ZERO)          ;   //***Write data to Reg : Turn recorded audio volume 
    13fa:	6c e7       	ldi	r22, 0x7C	; 124
    13fc:	74 e2       	ldi	r23, 0x24	; 36
    13fe:	80 e1       	ldi	r24, 0x10	; 16
    1400:	90 e0       	ldi	r25, 0x00	; 0
    1402:	40 e0       	ldi	r20, 0x00	; 0
    1404:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>
  FT800memWrite8(REG_VOL_SOUND,0x80)       ;   //***Write data to Reg : Turn synthesizer volume 50%(100%=0xFF)  
    1408:	60 e8       	ldi	r22, 0x80	; 128
    140a:	74 e2       	ldi	r23, 0x24	; 36
    140c:	80 e1       	ldi	r24, 0x10	; 16
    140e:	90 e0       	ldi	r25, 0x00	; 0
    1410:	40 e8       	ldi	r20, 0x80	; 128
    1412:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>
 
  FT800memWrite16(REG_SOUND,0x0000)        ;   //***Write data to Reg : Select Sound Effect = Silence(No Sound) 
    1416:	64 e8       	ldi	r22, 0x84	; 132
    1418:	74 e2       	ldi	r23, 0x24	; 36
    141a:	80 e1       	ldi	r24, 0x10	; 16
    141c:	90 e0       	ldi	r25, 0x00	; 0
    141e:	40 e0       	ldi	r20, 0x00	; 0
    1420:	50 e0       	ldi	r21, 0x00	; 0
    1422:	0e 94 bc 00 	call	0x178	; 0x178 <FT800memWrite16>
  FT800memWrite8(REG_PLAY,0x01)            ;   //***Write data to Reg : Play Sound Effect
    1426:	68 e8       	ldi	r22, 0x88	; 136
    1428:	74 e2       	ldi	r23, 0x24	; 36
    142a:	80 e1       	ldi	r24, 0x10	; 16
    142c:	90 e0       	ldi	r25, 0x00	; 0
    142e:	41 e0       	ldi	r20, 0x01	; 1
    1430:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>

 //------------------ 5.Write Initial Display List & Enable Display -----------------


  FT800memWrite32(RAM_DL+DL_Offset,DL_CLEAR_RGB)  ;   //***Sent DL-CMD Clear color BackGround to Black (default)
    1434:	60 91 38 01 	lds	r22, 0x0138
    1438:	70 91 39 01 	lds	r23, 0x0139
    143c:	80 e0       	ldi	r24, 0x00	; 0
    143e:	90 e0       	ldi	r25, 0x00	; 0
    1440:	60 50       	subi	r22, 0x00	; 0
    1442:	70 40       	sbci	r23, 0x00	; 0
    1444:	80 4f       	sbci	r24, 0xF0	; 240
    1446:	9f 4f       	sbci	r25, 0xFF	; 255
    1448:	20 e0       	ldi	r18, 0x00	; 0
    144a:	30 e0       	ldi	r19, 0x00	; 0
    144c:	40 e0       	ldi	r20, 0x00	; 0
    144e:	52 e0       	ldi	r21, 0x02	; 2
    1450:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>
  DL_Offset += 4                                  ;   //Update Offset pointer Ram-DL 4 byte for Next DL-CMD
    1454:	60 91 38 01 	lds	r22, 0x0138
    1458:	70 91 39 01 	lds	r23, 0x0139
    145c:	6c 5f       	subi	r22, 0xFC	; 252
    145e:	7f 4f       	sbci	r23, 0xFF	; 255
    1460:	70 93 39 01 	sts	0x0139, r23
    1464:	60 93 38 01 	sts	0x0138, r22

  FT800memWrite32(RAM_DL+DL_Offset,(DL_CLEAR | CLR_COL | CLR_STN | CLR_TAG));   //***Sent DL-CMD Clear C/S/T define which parameters to clear
    1468:	80 e0       	ldi	r24, 0x00	; 0
    146a:	90 e0       	ldi	r25, 0x00	; 0
    146c:	60 50       	subi	r22, 0x00	; 0
    146e:	70 40       	sbci	r23, 0x00	; 0
    1470:	80 4f       	sbci	r24, 0xF0	; 240
    1472:	9f 4f       	sbci	r25, 0xFF	; 255
    1474:	27 e0       	ldi	r18, 0x07	; 7
    1476:	30 e0       	ldi	r19, 0x00	; 0
    1478:	40 e0       	ldi	r20, 0x00	; 0
    147a:	56 e2       	ldi	r21, 0x26	; 38
    147c:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>
  DL_Offset += 4                                  ;     //Update Offset pointer Ram-DL 4 byte for Next DL-CMD
    1480:	60 91 38 01 	lds	r22, 0x0138
    1484:	70 91 39 01 	lds	r23, 0x0139
    1488:	6c 5f       	subi	r22, 0xFC	; 252
    148a:	7f 4f       	sbci	r23, 0xFF	; 255
    148c:	70 93 39 01 	sts	0x0139, r23
    1490:	60 93 38 01 	sts	0x0138, r22

  FT800memWrite32(RAM_DL+DL_Offset,DL_DISPLAY)    ;   //***Sent DL-CMD for end of display list
    1494:	80 e0       	ldi	r24, 0x00	; 0
    1496:	90 e0       	ldi	r25, 0x00	; 0
    1498:	60 50       	subi	r22, 0x00	; 0
    149a:	70 40       	sbci	r23, 0x00	; 0
    149c:	80 4f       	sbci	r24, 0xF0	; 240
    149e:	9f 4f       	sbci	r25, 0xFF	; 255
    14a0:	20 e0       	ldi	r18, 0x00	; 0
    14a2:	30 e0       	ldi	r19, 0x00	; 0
    14a4:	40 e0       	ldi	r20, 0x00	; 0
    14a6:	50 e0       	ldi	r21, 0x00	; 0
    14a8:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>

  FT800memWrite32(REG_DLSWAP,DLSWAP_FRAME )       ;   //***Write data(0x02) to Reg : Display List Execute
    14ac:	60 e5       	ldi	r22, 0x50	; 80
    14ae:	74 e2       	ldi	r23, 0x24	; 36
    14b0:	80 e1       	ldi	r24, 0x10	; 16
    14b2:	90 e0       	ldi	r25, 0x00	; 0
    14b4:	22 e0       	ldi	r18, 0x02	; 2
    14b6:	30 e0       	ldi	r19, 0x00	; 0
    14b8:	40 e0       	ldi	r20, 0x00	; 0
    14ba:	50 e0       	ldi	r21, 0x00	; 0
    14bc:	0e 94 e3 00 	call	0x1c6	; 0x1c6 <FT800memWrite32>
                                                
  DL_Offset = 0                                   ;   //Reset Display List offset pointer=0 for new Display list
    14c0:	10 92 39 01 	sts	0x0139, r1
    14c4:	10 92 38 01 	sts	0x0138, r1
  
  ft800Gpio = FT800memRead8(REG_GPIO)             ;   //***Read the FT800 GPIO register for a read/modify/write operation
    14c8:	60 e9       	ldi	r22, 0x90	; 144
    14ca:	74 e2       	ldi	r23, 0x24	; 36
    14cc:	80 e1       	ldi	r24, 0x10	; 16
    14ce:	90 e0       	ldi	r25, 0x00	; 0
    14d0:	0e 94 65 01 	call	0x2ca	; 0x2ca <FT800memRead8>
  ft800Gpio = ft800Gpio | 0x80                    ;   //set bit 7 of FT800 GPIO register (DISP) - others are inputs
    14d4:	48 2f       	mov	r20, r24
    14d6:	40 68       	ori	r20, 0x80	; 128
    14d8:	40 93 40 01 	sts	0x0140, r20

  FT800memWrite8(REG_GPIO,ft800Gpio)              ;   //***Write Data to Reg : Enable the DISP signal to the LCD panel
    14dc:	60 e9       	ldi	r22, 0x90	; 144
    14de:	74 e2       	ldi	r23, 0x24	; 36
    14e0:	80 e1       	ldi	r24, 0x10	; 16
    14e2:	90 e0       	ldi	r25, 0x00	; 0
    14e4:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>
  FT800memWrite8(REG_PCLK,5)                      ;   //***Write Data to Reg : Now start clocking data to the LCD panel
    14e8:	6c e6       	ldi	r22, 0x6C	; 108
    14ea:	74 e2       	ldi	r23, 0x24	; 36
    14ec:	80 e1       	ldi	r24, 0x10	; 16
    14ee:	90 e0       	ldi	r25, 0x00	; 0
    14f0:	45 e0       	ldi	r20, 0x05	; 5
    14f2:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>
    14f6:	10 e0       	ldi	r17, 0x00	; 0
    14f8:	c0 ea       	ldi	r28, 0xA0	; 160
    14fa:	df e0       	ldi	r29, 0x0F	; 15
 
  for(duty = 0; duty <= 128; duty++)
   {
     FT800memWrite8(REG_PWM_DUTY, duty);            //***Write Data to Reg : Turn on backlight - ramp up slowly to full brighness
    14fc:	64 ec       	ldi	r22, 0xC4	; 196
    14fe:	74 e2       	ldi	r23, 0x24	; 36
    1500:	80 e1       	ldi	r24, 0x10	; 16
    1502:	90 e0       	ldi	r25, 0x00	; 0
    1504:	41 2f       	mov	r20, r17
    1506:	0e 94 9a 00 	call	0x134	; 0x134 <FT800memWrite8>
    150a:	8a e0       	ldi	r24, 0x0A	; 10
    150c:	90 e0       	ldi	r25, 0x00	; 0
    150e:	fe 01       	movw	r30, r28
    1510:	31 97       	sbiw	r30, 0x01	; 1
    1512:	f1 f7       	brne	.-4      	; 0x1510 <FT800_Initial+0x2ec>
 ++                                                ++
 +++++++++++++++++++++++++++++++++++++++++++++++++++*/

 void delay_ms(unsigned int cnt)
  {
    for(;cnt>0;cnt--)
    1514:	01 97       	sbiw	r24, 0x01	; 1
    1516:	d9 f7       	brne	.-10     	; 0x150e <FT800_Initial+0x2ea>
    1518:	1f 5f       	subi	r17, 0xFF	; 255
  ft800Gpio = ft800Gpio | 0x80                    ;   //set bit 7 of FT800 GPIO register (DISP) - others are inputs

  FT800memWrite8(REG_GPIO,ft800Gpio)              ;   //***Write Data to Reg : Enable the DISP signal to the LCD panel
  FT800memWrite8(REG_PCLK,5)                      ;   //***Write Data to Reg : Now start clocking data to the LCD panel
 
  for(duty = 0; duty <= 128; duty++)
    151a:	11 38       	cpi	r17, 0x81	; 129
    151c:	79 f7       	brne	.-34     	; 0x14fc <FT800_Initial+0x2d8>
    151e:	8a e0       	ldi	r24, 0x0A	; 10
    1520:	90 e0       	ldi	r25, 0x00	; 0
    1522:	20 ea       	ldi	r18, 0xA0	; 160
    1524:	3f e0       	ldi	r19, 0x0F	; 15
    1526:	f9 01       	movw	r30, r18
    1528:	31 97       	sbiw	r30, 0x01	; 1
    152a:	f1 f7       	brne	.-4      	; 0x1528 <FT800_Initial+0x304>
 ++                                                ++
 +++++++++++++++++++++++++++++++++++++++++++++++++++*/

 void delay_ms(unsigned int cnt)
  {
    for(;cnt>0;cnt--)
    152c:	01 97       	sbiw	r24, 0x01	; 1
    152e:	d9 f7       	brne	.-10     	; 0x1526 <FT800_Initial+0x302>
     delay_ms(10);
   }
  
  delay_ms(10);

 }
    1530:	df 91       	pop	r29
    1532:	cf 91       	pop	r28
    1534:	1f 91       	pop	r17
    1536:	08 95       	ret

00001538 <Update_Screen>:
  ++           color_point = Value Update for Color poin                          ++
  ++                                                                              ++
  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

  void Update_Screen(long color_point,char *tx)
   {
    1538:	2f 92       	push	r2
    153a:	3f 92       	push	r3
    153c:	4f 92       	push	r4
    153e:	5f 92       	push	r5
    1540:	6f 92       	push	r6
    1542:	7f 92       	push	r7
    1544:	8f 92       	push	r8
    1546:	9f 92       	push	r9
    1548:	af 92       	push	r10
    154a:	bf 92       	push	r11
    154c:	cf 92       	push	r12
    154e:	df 92       	push	r13
    1550:	ef 92       	push	r14
    1552:	ff 92       	push	r15
    1554:	0f 93       	push	r16
    1556:	1f 93       	push	r17
    1558:	2b 01       	movw	r4, r22
    155a:	3c 01       	movw	r6, r24
    155c:	1a 01       	movw	r2, r20
      
    //----------------- 1.Start Display List ------------------------
      
     Start_CMDList(Yellow)   ;
    155e:	60 e0       	ldi	r22, 0x00	; 0
    1560:	7f ef       	ldi	r23, 0xFF	; 255
    1562:	8f ef       	ldi	r24, 0xFF	; 255
    1564:	90 e0       	ldi	r25, 0x00	; 0
    1566:	0e 94 93 02 	call	0x526	; 0x526 <Start_CMDList>

  
   //------------------ 2.User Program ------------------------- 

  
   Rect_DL(10,10,470,262,1,Red)                     ;
    156a:	00 d0       	rcall	.+0      	; 0x156c <Update_Screen+0x34>
    156c:	00 d0       	rcall	.+0      	; 0x156e <Update_Screen+0x36>
    156e:	80 e0       	ldi	r24, 0x00	; 0
    1570:	90 e0       	ldi	r25, 0x00	; 0
    1572:	af ef       	ldi	r26, 0xFF	; 255
    1574:	b0 e0       	ldi	r27, 0x00	; 0
    1576:	ed b7       	in	r30, 0x3d	; 61
    1578:	fe b7       	in	r31, 0x3e	; 62
    157a:	81 83       	std	Z+1, r24	; 0x01
    157c:	92 83       	std	Z+2, r25	; 0x02
    157e:	a3 83       	std	Z+3, r26	; 0x03
    1580:	b4 83       	std	Z+4, r27	; 0x04
    1582:	6a e0       	ldi	r22, 0x0A	; 10
    1584:	70 e0       	ldi	r23, 0x00	; 0
    1586:	80 e0       	ldi	r24, 0x00	; 0
    1588:	90 e0       	ldi	r25, 0x00	; 0
    158a:	2a e0       	ldi	r18, 0x0A	; 10
    158c:	30 e0       	ldi	r19, 0x00	; 0
    158e:	40 e0       	ldi	r20, 0x00	; 0
    1590:	50 e0       	ldi	r21, 0x00	; 0
    1592:	16 ed       	ldi	r17, 0xD6	; 214
    1594:	e1 2e       	mov	r14, r17
    1596:	11 e0       	ldi	r17, 0x01	; 1
    1598:	f1 2e       	mov	r15, r17
    159a:	01 2d       	mov	r16, r1
    159c:	11 2d       	mov	r17, r1
    159e:	b6 e0       	ldi	r27, 0x06	; 6
    15a0:	ab 2e       	mov	r10, r27
    15a2:	b1 e0       	ldi	r27, 0x01	; 1
    15a4:	bb 2e       	mov	r11, r27
    15a6:	c1 2c       	mov	r12, r1
    15a8:	d1 2c       	mov	r13, r1
    15aa:	a1 e0       	ldi	r26, 0x01	; 1
    15ac:	8a 2e       	mov	r8, r26
    15ae:	91 2c       	mov	r9, r1
    15b0:	0e 94 18 07 	call	0xe30	; 0xe30 <Rect_DL>
   Rect_DL(50,80,255,120,1,White)                   ;
    15b4:	8f ef       	ldi	r24, 0xFF	; 255
    15b6:	9f ef       	ldi	r25, 0xFF	; 255
    15b8:	af ef       	ldi	r26, 0xFF	; 255
    15ba:	b0 e0       	ldi	r27, 0x00	; 0
    15bc:	ed b7       	in	r30, 0x3d	; 61
    15be:	fe b7       	in	r31, 0x3e	; 62
    15c0:	81 83       	std	Z+1, r24	; 0x01
    15c2:	92 83       	std	Z+2, r25	; 0x02
    15c4:	a3 83       	std	Z+3, r26	; 0x03
    15c6:	b4 83       	std	Z+4, r27	; 0x04
    15c8:	62 e3       	ldi	r22, 0x32	; 50
    15ca:	70 e0       	ldi	r23, 0x00	; 0
    15cc:	80 e0       	ldi	r24, 0x00	; 0
    15ce:	90 e0       	ldi	r25, 0x00	; 0
    15d0:	20 e5       	ldi	r18, 0x50	; 80
    15d2:	30 e0       	ldi	r19, 0x00	; 0
    15d4:	40 e0       	ldi	r20, 0x00	; 0
    15d6:	50 e0       	ldi	r21, 0x00	; 0
    15d8:	ff ef       	ldi	r31, 0xFF	; 255
    15da:	ef 2e       	mov	r14, r31
    15dc:	f1 2c       	mov	r15, r1
    15de:	01 2d       	mov	r16, r1
    15e0:	11 2d       	mov	r17, r1
    15e2:	e8 e7       	ldi	r30, 0x78	; 120
    15e4:	ae 2e       	mov	r10, r30
    15e6:	b1 2c       	mov	r11, r1
    15e8:	c1 2c       	mov	r12, r1
    15ea:	d1 2c       	mov	r13, r1
    15ec:	0e 94 18 07 	call	0xe30	; 0xe30 <Rect_DL>
   Point_DL(30,100,7,color_point)                   ;
    15f0:	0f 90       	pop	r0
    15f2:	0f 90       	pop	r0
    15f4:	0f 90       	pop	r0
    15f6:	0f 90       	pop	r0
    15f8:	6e e1       	ldi	r22, 0x1E	; 30
    15fa:	70 e0       	ldi	r23, 0x00	; 0
    15fc:	80 e0       	ldi	r24, 0x00	; 0
    15fe:	90 e0       	ldi	r25, 0x00	; 0
    1600:	24 e6       	ldi	r18, 0x64	; 100
    1602:	30 e0       	ldi	r19, 0x00	; 0
    1604:	40 e0       	ldi	r20, 0x00	; 0
    1606:	50 e0       	ldi	r21, 0x00	; 0
    1608:	07 e0       	ldi	r16, 0x07	; 7
    160a:	10 e0       	ldi	r17, 0x00	; 0
    160c:	73 01       	movw	r14, r6
    160e:	62 01       	movw	r12, r4
    1610:	0e 94 3a 08 	call	0x1074	; 0x1074 <Point_DL>

   Keys_CMD("123",270,80,170,40,30,0,White,Blue)    ;   
    1614:	00 d0       	rcall	.+0      	; 0x1616 <Update_Screen+0xde>
    1616:	00 d0       	rcall	.+0      	; 0x1618 <Update_Screen+0xe0>
    1618:	1f ef       	ldi	r17, 0xFF	; 255
    161a:	41 2e       	mov	r4, r17
    161c:	51 2c       	mov	r5, r1
    161e:	61 2c       	mov	r6, r1
    1620:	71 2c       	mov	r7, r1
    1622:	ed b7       	in	r30, 0x3d	; 61
    1624:	fe b7       	in	r31, 0x3e	; 62
    1626:	41 82       	std	Z+1, r4	; 0x01
    1628:	52 82       	std	Z+2, r5	; 0x02
    162a:	63 82       	std	Z+3, r6	; 0x03
    162c:	74 82       	std	Z+4, r7	; 0x04
    162e:	84 e1       	ldi	r24, 0x14	; 20
    1630:	91 e0       	ldi	r25, 0x01	; 1
    1632:	6e e0       	ldi	r22, 0x0E	; 14
    1634:	71 e0       	ldi	r23, 0x01	; 1
    1636:	40 e5       	ldi	r20, 0x50	; 80
    1638:	50 e0       	ldi	r21, 0x00	; 0
    163a:	2a ea       	ldi	r18, 0xAA	; 170
    163c:	30 e0       	ldi	r19, 0x00	; 0
    163e:	08 e2       	ldi	r16, 0x28	; 40
    1640:	10 e0       	ldi	r17, 0x00	; 0
    1642:	be e1       	ldi	r27, 0x1E	; 30
    1644:	eb 2e       	mov	r14, r27
    1646:	f1 2c       	mov	r15, r1
    1648:	cc 24       	eor	r12, r12
    164a:	dd 24       	eor	r13, r13
    164c:	af ef       	ldi	r26, 0xFF	; 255
    164e:	8a 2e       	mov	r8, r26
    1650:	af ef       	ldi	r26, 0xFF	; 255
    1652:	9a 2e       	mov	r9, r26
    1654:	af ef       	ldi	r26, 0xFF	; 255
    1656:	aa 2e       	mov	r10, r26
    1658:	b1 2c       	mov	r11, r1
    165a:	0e 94 54 03 	call	0x6a8	; 0x6a8 <Keys_CMD>
   Keys_CMD("456",270,124,170,40,30,0,White,Blue)   ;
    165e:	ed b7       	in	r30, 0x3d	; 61
    1660:	fe b7       	in	r31, 0x3e	; 62
    1662:	41 82       	std	Z+1, r4	; 0x01
    1664:	52 82       	std	Z+2, r5	; 0x02
    1666:	63 82       	std	Z+3, r6	; 0x03
    1668:	74 82       	std	Z+4, r7	; 0x04
    166a:	88 e1       	ldi	r24, 0x18	; 24
    166c:	91 e0       	ldi	r25, 0x01	; 1
    166e:	6e e0       	ldi	r22, 0x0E	; 14
    1670:	71 e0       	ldi	r23, 0x01	; 1
    1672:	4c e7       	ldi	r20, 0x7C	; 124
    1674:	50 e0       	ldi	r21, 0x00	; 0
    1676:	2a ea       	ldi	r18, 0xAA	; 170
    1678:	30 e0       	ldi	r19, 0x00	; 0
    167a:	0e 94 54 03 	call	0x6a8	; 0x6a8 <Keys_CMD>
   Keys_CMD("789",270,168,170,40,30,0,White,Blue)   ;
    167e:	ed b7       	in	r30, 0x3d	; 61
    1680:	fe b7       	in	r31, 0x3e	; 62
    1682:	41 82       	std	Z+1, r4	; 0x01
    1684:	52 82       	std	Z+2, r5	; 0x02
    1686:	63 82       	std	Z+3, r6	; 0x03
    1688:	74 82       	std	Z+4, r7	; 0x04
    168a:	8c e1       	ldi	r24, 0x1C	; 28
    168c:	91 e0       	ldi	r25, 0x01	; 1
    168e:	6e e0       	ldi	r22, 0x0E	; 14
    1690:	71 e0       	ldi	r23, 0x01	; 1
    1692:	48 ea       	ldi	r20, 0xA8	; 168
    1694:	50 e0       	ldi	r21, 0x00	; 0
    1696:	2a ea       	ldi	r18, 0xAA	; 170
    1698:	30 e0       	ldi	r19, 0x00	; 0
    169a:	0e 94 54 03 	call	0x6a8	; 0x6a8 <Keys_CMD>
   Keys_CMD("*0#",270,211,170,40,30,0,White,Blue)   ;   
    169e:	ed b7       	in	r30, 0x3d	; 61
    16a0:	fe b7       	in	r31, 0x3e	; 62
    16a2:	41 82       	std	Z+1, r4	; 0x01
    16a4:	52 82       	std	Z+2, r5	; 0x02
    16a6:	63 82       	std	Z+3, r6	; 0x03
    16a8:	74 82       	std	Z+4, r7	; 0x04
    16aa:	80 e2       	ldi	r24, 0x20	; 32
    16ac:	91 e0       	ldi	r25, 0x01	; 1
    16ae:	6e e0       	ldi	r22, 0x0E	; 14
    16b0:	71 e0       	ldi	r23, 0x01	; 1
    16b2:	43 ed       	ldi	r20, 0xD3	; 211
    16b4:	50 e0       	ldi	r21, 0x00	; 0
    16b6:	2a ea       	ldi	r18, 0xAA	; 170
    16b8:	30 e0       	ldi	r19, 0x00	; 0
    16ba:	0e 94 54 03 	call	0x6a8	; 0x6a8 <Keys_CMD>
   Keys_CMD("C",85,150,120,80,30,0,White,Blue)      ;
    16be:	ed b7       	in	r30, 0x3d	; 61
    16c0:	fe b7       	in	r31, 0x3e	; 62
    16c2:	41 82       	std	Z+1, r4	; 0x01
    16c4:	52 82       	std	Z+2, r5	; 0x02
    16c6:	63 82       	std	Z+3, r6	; 0x03
    16c8:	74 82       	std	Z+4, r7	; 0x04
    16ca:	84 e2       	ldi	r24, 0x24	; 36
    16cc:	91 e0       	ldi	r25, 0x01	; 1
    16ce:	65 e5       	ldi	r22, 0x55	; 85
    16d0:	70 e0       	ldi	r23, 0x00	; 0
    16d2:	46 e9       	ldi	r20, 0x96	; 150
    16d4:	50 e0       	ldi	r21, 0x00	; 0
    16d6:	28 e7       	ldi	r18, 0x78	; 120
    16d8:	30 e0       	ldi	r19, 0x00	; 0
    16da:	00 e5       	ldi	r16, 0x50	; 80
    16dc:	10 e0       	ldi	r17, 0x00	; 0
    16de:	0e 94 54 03 	call	0x6a8	; 0x6a8 <Keys_CMD>

   Text_CMD(tx,60,85,30,0,MidnightBlue)             ;  //Display Text When Press Button 
    16e2:	0f 90       	pop	r0
    16e4:	0f 90       	pop	r0
    16e6:	0f 90       	pop	r0
    16e8:	0f 90       	pop	r0
    16ea:	c1 01       	movw	r24, r2
    16ec:	6c e3       	ldi	r22, 0x3C	; 60
    16ee:	70 e0       	ldi	r23, 0x00	; 0
    16f0:	45 e5       	ldi	r20, 0x55	; 85
    16f2:	50 e0       	ldi	r21, 0x00	; 0
    16f4:	2e e1       	ldi	r18, 0x1E	; 30
    16f6:	30 e0       	ldi	r19, 0x00	; 0
    16f8:	00 e0       	ldi	r16, 0x00	; 0
    16fa:	10 e0       	ldi	r17, 0x00	; 0
    16fc:	f0 e7       	ldi	r31, 0x70	; 112
    16fe:	cf 2e       	mov	r12, r31
    1700:	f9 e1       	ldi	r31, 0x19	; 25
    1702:	df 2e       	mov	r13, r31
    1704:	f9 e1       	ldi	r31, 0x19	; 25
    1706:	ef 2e       	mov	r14, r31
    1708:	f1 2c       	mov	r15, r1
    170a:	0e 94 c0 04 	call	0x980	; 0x980 <Text_CMD>

   Text_CMD("ET-DEMO KEY-DTMF",80,20,25,0,Green)    ;  //Display Text "ET-DEMO KEY-DTMF"
    170e:	86 e2       	ldi	r24, 0x26	; 38
    1710:	91 e0       	ldi	r25, 0x01	; 1
    1712:	60 e5       	ldi	r22, 0x50	; 80
    1714:	70 e0       	ldi	r23, 0x00	; 0
    1716:	44 e1       	ldi	r20, 0x14	; 20
    1718:	50 e0       	ldi	r21, 0x00	; 0
    171a:	29 e1       	ldi	r18, 0x19	; 25
    171c:	30 e0       	ldi	r19, 0x00	; 0
    171e:	c1 2c       	mov	r12, r1
    1720:	ef ef       	ldi	r30, 0xFF	; 255
    1722:	de 2e       	mov	r13, r30
    1724:	e1 2c       	mov	r14, r1
    1726:	f1 2c       	mov	r15, r1
    1728:	0e 94 c0 04 	call	0x980	; 0x980 <Text_CMD>

    //----------------- 3.End Display List and Update Execute -------------

   End_CMDList();
    172c:	0e 94 03 03 	call	0x606	; 0x606 <End_CMDList>

   }
    1730:	1f 91       	pop	r17
    1732:	0f 91       	pop	r16
    1734:	ff 90       	pop	r15
    1736:	ef 90       	pop	r14
    1738:	df 90       	pop	r13
    173a:	cf 90       	pop	r12
    173c:	bf 90       	pop	r11
    173e:	af 90       	pop	r10
    1740:	9f 90       	pop	r9
    1742:	8f 90       	pop	r8
    1744:	7f 90       	pop	r7
    1746:	6f 90       	pop	r6
    1748:	5f 90       	pop	r5
    174a:	4f 90       	pop	r4
    174c:	3f 90       	pop	r3
    174e:	2f 90       	pop	r2
    1750:	08 95       	ret

00001752 <User_App>:
  ++                                                                              ++
  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/


 void User_App(void)
  {
    1752:	2f 92       	push	r2
    1754:	3f 92       	push	r3
    1756:	4f 92       	push	r4
    1758:	5f 92       	push	r5
    175a:	6f 92       	push	r6
    175c:	7f 92       	push	r7
    175e:	8f 92       	push	r8
    1760:	9f 92       	push	r9
    1762:	af 92       	push	r10
    1764:	bf 92       	push	r11
    1766:	cf 92       	push	r12
    1768:	df 92       	push	r13
    176a:	ef 92       	push	r14
    176c:	ff 92       	push	r15
    176e:	0f 93       	push	r16
    1770:	1f 93       	push	r17
    1772:	df 93       	push	r29
    1774:	cf 93       	push	r28
    1776:	cd b7       	in	r28, 0x3d	; 61
    1778:	de b7       	in	r29, 0x3e	; 62
    177a:	2b 97       	sbiw	r28, 0x0b	; 11
    177c:	0f b6       	in	r0, 0x3f	; 63
    177e:	f8 94       	cli
    1780:	de bf       	out	0x3e, r29	; 62
    1782:	0f be       	out	0x3f, r0	; 63
    1784:	cd bf       	out	0x3d, r28	; 61
     unsigned char num=0               ;
     char bt[11]  = {" "}              ;  //Start Text Blank  in Rectangle White
    1786:	80 e2       	ldi	r24, 0x20	; 32
    1788:	90 e0       	ldi	r25, 0x00	; 0
    178a:	a0 e0       	ldi	r26, 0x00	; 0
    178c:	b0 e0       	ldi	r27, 0x00	; 0
    178e:	89 83       	std	Y+1, r24	; 0x01
    1790:	9a 83       	std	Y+2, r25	; 0x02
    1792:	ab 83       	std	Y+3, r26	; 0x03
    1794:	bc 83       	std	Y+4, r27	; 0x04
    1796:	fe 01       	movw	r30, r28
    1798:	35 96       	adiw	r30, 0x05	; 5
    179a:	87 e0       	ldi	r24, 0x07	; 7
    179c:	df 01       	movw	r26, r30
    179e:	1d 92       	st	X+, r1
    17a0:	8a 95       	dec	r24
    17a2:	e9 f7       	brne	.-6      	; 0x179e <User_App+0x4c>

    
   Update_Screen(Black,bt) ; 
    17a4:	60 e0       	ldi	r22, 0x00	; 0
    17a6:	70 e0       	ldi	r23, 0x00	; 0
    17a8:	80 e0       	ldi	r24, 0x00	; 0
    17aa:	90 e0       	ldi	r25, 0x00	; 0
    17ac:	7e 01       	movw	r14, r28
    17ae:	08 94       	sec
    17b0:	e1 1c       	adc	r14, r1
    17b2:	f1 1c       	adc	r15, r1
    17b4:	a7 01       	movw	r20, r14
    17b6:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>
    17ba:	00 e0       	ldi	r16, 0x00	; 0
    17bc:	f0 ea       	ldi	r31, 0xA0	; 160
    17be:	af 2e       	mov	r10, r31
    17c0:	ff e0       	ldi	r31, 0x0F	; 15
    17c2:	bf 2e       	mov	r11, r31
         { 
          //Y-Touch Key"C"//
           if((tc_y>150)&(tc_y<230))              //Check Position Touch Y-axis for key "C"
            {
               
              for(num=0;num<10;num++)       
    17c4:	eb e0       	ldi	r30, 0x0B	; 11
    17c6:	ce 2e       	mov	r12, r30
    17c8:	d1 2c       	mov	r13, r1
    17ca:	cc 0e       	add	r12, r28
    17cc:	dd 1e       	adc	r13, r29

         if((tc_y>168)&(tc_y<208))               //Check Position Touch Y-axis for Key"9"
          {  
            if(num < 10)                         //Check Number Charecter limit display text 10 Charecter
             {
              bt[num] = '9'                    ;   //Set Text Key"9"
    17ce:	79 e3       	ldi	r23, 0x39	; 57
    17d0:	57 2e       	mov	r5, r23

          if((tc_y>124)&(tc_y<164))               //Check Position Touch Y-axis for Key"6"
          {  
           if(num < 10)                           //Check Number Charecter limit display text 10 Charecter
             {
               bt[num] = '6'                  ;   //Set Text Key"6"
    17d2:	66 e3       	ldi	r22, 0x36	; 54
    17d4:	46 2e       	mov	r4, r22

           if((tc_y>80)&(tc_y<120))                //Check Position Touch Y-axis for key"3"
           {      
            if(num < 10)                           //Check Number Charecter limit display text 10 Charecter
             {
               bt[num] = '3'                   ;  //Set Text key "3"
    17d6:	53 e3       	ldi	r21, 0x33	; 51
    17d8:	35 2e       	mov	r3, r21

         if((tc_y>212)&(tc_y<252))            //Check Position Touch Y-axis for Key"0"
          {  
            if(num < 10)                      //Check Number Charecter limit display text 10 Charecter
             {
               bt[num] = '0'               ;  //Set Text Key"0"
    17da:	40 e3       	ldi	r20, 0x30	; 48
    17dc:	24 2e       	mov	r2, r20

          if((tc_y>80)&(tc_y<120))            //Check Position Touch Y-axis for key"2"
           {       
            if(num < 10)                      //Check Number Charecter limit display text 10 Charecter
             {
              bt[num] = '2'                ;  //Set Text key "2"
    17de:	12 e3       	ldi	r17, 0x32	; 50

           if((tc_y>212)&(tc_y<252))                //Check Position Touch Y-axis for Key"*"
            {  
              if(num < 10)                          //Check Number Charecter limit display text 10 Charecter
               {
                 bt[num] = '*'                   ;  //Set Text Key"*"
    17e0:	3a e2       	ldi	r19, 0x2A	; 42
    17e2:	93 2e       	mov	r9, r19

           if((tc_y>168)&(tc_y<208))                //Check Position Touch Y-axis for Key"7"
            {  
              if(num < 10)                           //Check Number Charecter limit display text 10 Charecter
               { 
                bt[num] = '7'                 ;     //Set Text Key"7"
    17e4:	27 e3       	ldi	r18, 0x37	; 55
    17e6:	82 2e       	mov	r8, r18

           if((tc_y>124)&(tc_y<164))             //Check Position Touch Y-axis for Key"4"
            {  
             if(num < 10)                        //Check Number Charecter limit display text 10 Charecter
                {
                  bt[num] = '4'               ;  //Set Text Key"4"
    17e8:	94 e3       	ldi	r25, 0x34	; 52
    17ea:	79 2e       	mov	r7, r25

           if((tc_y>80)&(tc_y<120))            //Check Position Touch Y-axis for key"1"
            {       
             if(num < 10)                      //Check Number Charecter limit display text 10 Charecter
              {
                bt[num] = '1'               ;  //Set Text key"1"
    17ec:	81 e3       	ldi	r24, 0x31	; 49
    17ee:	68 2e       	mov	r6, r24
   while(1)
    { 

    //-------- Check Statust Touch Screen ---------
         
     if(Touch_Detect())                        //if Touch =1 
    17f0:	0e 94 50 02 	call	0x4a0	; 0x4a0 <Touch_Detect>
    17f4:	88 23       	and	r24, r24
    17f6:	e1 f3       	breq	.-8      	; 0x17f0 <User_App+0x9e>
      {
        Touch_Read_XY()          ;             //Read Position Touch Screen XY
    17f8:	0e 94 5d 02 	call	0x4ba	; 0x4ba <Touch_Read_XY>

        //----------------------Check Key"1,4,7,*"------------------------//

           //X-Touch Button "1,4,7,*"

        if((tc_x>255) & (tc_x <309))           //Check Position Touch X-axis for Key"1,4,7,*"
    17fc:	80 91 42 01 	lds	r24, 0x0142
    1800:	90 91 43 01 	lds	r25, 0x0143
    1804:	80 50       	subi	r24, 0x00	; 0
    1806:	91 40       	sbci	r25, 0x01	; 1
    1808:	c5 97       	sbiw	r24, 0x35	; 53
    180a:	08 f0       	brcs	.+2      	; 0x180e <User_App+0xbc>
    180c:	74 c0       	rjmp	.+232    	; 0x18f6 <User_App+0x1a4>
         { 
          //----Y-Touch Key"1"-----//

           if((tc_y>80)&(tc_y<120))            //Check Position Touch Y-axis for key"1"
    180e:	80 91 44 01 	lds	r24, 0x0144
    1812:	90 91 45 01 	lds	r25, 0x0145
    1816:	81 55       	subi	r24, 0x51	; 81
    1818:	90 40       	sbci	r25, 0x00	; 0
    181a:	87 97       	sbiw	r24, 0x27	; 39
    181c:	a8 f4       	brcc	.+42     	; 0x1848 <User_App+0xf6>
            {       
             if(num < 10)                      //Check Number Charecter limit display text 10 Charecter
    181e:	0a 30       	cpi	r16, 0x0A	; 10
    1820:	28 f4       	brcc	.+10     	; 0x182c <User_App+0xda>
              {
                bt[num] = '1'               ;  //Set Text key"1"
    1822:	f7 01       	movw	r30, r14
    1824:	e0 0f       	add	r30, r16
    1826:	f1 1d       	adc	r31, r1
    1828:	60 82       	st	Z, r6
                num += 1                    ;  //Increment Number Text
    182a:	0f 5f       	subi	r16, 0xFF	; 255
              }

             Sound_Effect(100,midC,DTMF1)   ;  //Set Sound DTMF1 when Press key"1"
    182c:	84 e6       	ldi	r24, 0x64	; 100
    182e:	60 e0       	ldi	r22, 0x00	; 0
    1830:	70 e0       	ldi	r23, 0x00	; 0
    1832:	41 e3       	ldi	r20, 0x31	; 49
    1834:	50 e0       	ldi	r21, 0x00	; 0
    1836:	0e 94 71 02 	call	0x4e2	; 0x4e2 <Sound_Effect>
             Update_Screen(Green,bt)        ;  //Update Screen
    183a:	60 e0       	ldi	r22, 0x00	; 0
    183c:	7f ef       	ldi	r23, 0xFF	; 255
    183e:	80 e0       	ldi	r24, 0x00	; 0
    1840:	90 e0       	ldi	r25, 0x00	; 0
    1842:	a7 01       	movw	r20, r14
    1844:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>
          
            } 

             //------Y-Touch Key"4"------//

           if((tc_y>124)&(tc_y<164))             //Check Position Touch Y-axis for Key"4"
    1848:	80 91 44 01 	lds	r24, 0x0144
    184c:	90 91 45 01 	lds	r25, 0x0145
    1850:	8d 57       	subi	r24, 0x7D	; 125
    1852:	90 40       	sbci	r25, 0x00	; 0
    1854:	87 97       	sbiw	r24, 0x27	; 39
    1856:	a8 f4       	brcc	.+42     	; 0x1882 <User_App+0x130>
            {  
             if(num < 10)                        //Check Number Charecter limit display text 10 Charecter
    1858:	0a 30       	cpi	r16, 0x0A	; 10
    185a:	28 f4       	brcc	.+10     	; 0x1866 <User_App+0x114>
                {
                  bt[num] = '4'               ;  //Set Text Key"4"
    185c:	f7 01       	movw	r30, r14
    185e:	e0 0f       	add	r30, r16
    1860:	f1 1d       	adc	r31, r1
    1862:	70 82       	st	Z, r7
                  num += 1                    ;  //Increment Number Text
    1864:	0f 5f       	subi	r16, 0xFF	; 255
                }
               
             Sound_Effect(100,midC,DTMF4)     ;  //Set Sound DTMF4 when Press key"4"
    1866:	84 e6       	ldi	r24, 0x64	; 100
    1868:	60 e0       	ldi	r22, 0x00	; 0
    186a:	70 e0       	ldi	r23, 0x00	; 0
    186c:	44 e3       	ldi	r20, 0x34	; 52
    186e:	50 e0       	ldi	r21, 0x00	; 0
    1870:	0e 94 71 02 	call	0x4e2	; 0x4e2 <Sound_Effect>
             Update_Screen(Green,bt)          ; 
    1874:	60 e0       	ldi	r22, 0x00	; 0
    1876:	7f ef       	ldi	r23, 0xFF	; 255
    1878:	80 e0       	ldi	r24, 0x00	; 0
    187a:	90 e0       	ldi	r25, 0x00	; 0
    187c:	a7 01       	movw	r20, r14
    187e:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>
            } 

        
             //------Y-Touch Key"7"------//

           if((tc_y>168)&(tc_y<208))                //Check Position Touch Y-axis for Key"7"
    1882:	80 91 44 01 	lds	r24, 0x0144
    1886:	90 91 45 01 	lds	r25, 0x0145
    188a:	89 5a       	subi	r24, 0xA9	; 169
    188c:	90 40       	sbci	r25, 0x00	; 0
    188e:	87 97       	sbiw	r24, 0x27	; 39
    1890:	a8 f4       	brcc	.+42     	; 0x18bc <User_App+0x16a>
            {  
              if(num < 10)                           //Check Number Charecter limit display text 10 Charecter
    1892:	0a 30       	cpi	r16, 0x0A	; 10
    1894:	28 f4       	brcc	.+10     	; 0x18a0 <User_App+0x14e>
               { 
                bt[num] = '7'                 ;     //Set Text Key"7"
    1896:	f7 01       	movw	r30, r14
    1898:	e0 0f       	add	r30, r16
    189a:	f1 1d       	adc	r31, r1
    189c:	80 82       	st	Z, r8
                num += 1                      ;     //Increment Number Text
    189e:	0f 5f       	subi	r16, 0xFF	; 255
               }
               
               Sound_Effect(100,midC,DTMF7)   ;     //Set Sound DTMF7 when Press key"7"
    18a0:	84 e6       	ldi	r24, 0x64	; 100
    18a2:	60 e0       	ldi	r22, 0x00	; 0
    18a4:	70 e0       	ldi	r23, 0x00	; 0
    18a6:	47 e3       	ldi	r20, 0x37	; 55
    18a8:	50 e0       	ldi	r21, 0x00	; 0
    18aa:	0e 94 71 02 	call	0x4e2	; 0x4e2 <Sound_Effect>
               Update_Screen(Green,bt)        ; 
    18ae:	60 e0       	ldi	r22, 0x00	; 0
    18b0:	7f ef       	ldi	r23, 0xFF	; 255
    18b2:	80 e0       	ldi	r24, 0x00	; 0
    18b4:	90 e0       	ldi	r25, 0x00	; 0
    18b6:	a7 01       	movw	r20, r14
    18b8:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>
              
            } 

               //------Y-Touch Key"*"------//

           if((tc_y>212)&(tc_y<252))                //Check Position Touch Y-axis for Key"*"
    18bc:	80 91 44 01 	lds	r24, 0x0144
    18c0:	90 91 45 01 	lds	r25, 0x0145
    18c4:	85 5d       	subi	r24, 0xD5	; 213
    18c6:	90 40       	sbci	r25, 0x00	; 0
    18c8:	87 97       	sbiw	r24, 0x27	; 39
    18ca:	a8 f4       	brcc	.+42     	; 0x18f6 <User_App+0x1a4>
            {  
              if(num < 10)                          //Check Number Charecter limit display text 10 Charecter
    18cc:	0a 30       	cpi	r16, 0x0A	; 10
    18ce:	28 f4       	brcc	.+10     	; 0x18da <User_App+0x188>
               {
                 bt[num] = '*'                   ;  //Set Text Key"*"
    18d0:	f7 01       	movw	r30, r14
    18d2:	e0 0f       	add	r30, r16
    18d4:	f1 1d       	adc	r31, r1
    18d6:	90 82       	st	Z, r9
                 num += 1                        ;  //Increment Number Text
    18d8:	0f 5f       	subi	r16, 0xFF	; 255
               }
               
             Sound_Effect(100,midC,DTMF_star)   ;  //Set Sound DTMF"*" when Press key"*"
    18da:	84 e6       	ldi	r24, 0x64	; 100
    18dc:	60 e0       	ldi	r22, 0x00	; 0
    18de:	70 e0       	ldi	r23, 0x00	; 0
    18e0:	4a e2       	ldi	r20, 0x2A	; 42
    18e2:	50 e0       	ldi	r21, 0x00	; 0
    18e4:	0e 94 71 02 	call	0x4e2	; 0x4e2 <Sound_Effect>
             Update_Screen(Green,bt)            ; 
    18e8:	60 e0       	ldi	r22, 0x00	; 0
    18ea:	7f ef       	ldi	r23, 0xFF	; 255
    18ec:	80 e0       	ldi	r24, 0x00	; 0
    18ee:	90 e0       	ldi	r25, 0x00	; 0
    18f0:	a7 01       	movw	r20, r14
    18f2:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>
        
       //----------------------Check Key"2,5,8,0"------------------------//

           //X-Touch Button "2,5,8,0"

       if((tc_x>313) & (tc_x <367))            //Check Position Touch X-axis for Key"2,5,8,0"
    18f6:	80 91 42 01 	lds	r24, 0x0142
    18fa:	90 91 43 01 	lds	r25, 0x0143
    18fe:	8a 53       	subi	r24, 0x3A	; 58
    1900:	91 40       	sbci	r25, 0x01	; 1
    1902:	c5 97       	sbiw	r24, 0x35	; 53
    1904:	08 f0       	brcs	.+2      	; 0x1908 <User_App+0x1b6>
    1906:	76 c0       	rjmp	.+236    	; 0x19f4 <User_App+0x2a2>
         { 
          //----Y-Touch Key"2"-----//

          if((tc_y>80)&(tc_y<120))            //Check Position Touch Y-axis for key"2"
    1908:	80 91 44 01 	lds	r24, 0x0144
    190c:	90 91 45 01 	lds	r25, 0x0145
    1910:	81 55       	subi	r24, 0x51	; 81
    1912:	90 40       	sbci	r25, 0x00	; 0
    1914:	87 97       	sbiw	r24, 0x27	; 39
    1916:	a8 f4       	brcc	.+42     	; 0x1942 <User_App+0x1f0>
           {       
            if(num < 10)                      //Check Number Charecter limit display text 10 Charecter
    1918:	0a 30       	cpi	r16, 0x0A	; 10
    191a:	28 f4       	brcc	.+10     	; 0x1926 <User_App+0x1d4>
             {
              bt[num] = '2'                ;  //Set Text key "2"
    191c:	f7 01       	movw	r30, r14
    191e:	e0 0f       	add	r30, r16
    1920:	f1 1d       	adc	r31, r1
    1922:	10 83       	st	Z, r17
              num += 1                     ;  //Increment Number Text
    1924:	0f 5f       	subi	r16, 0xFF	; 255
             }

             Sound_Effect(100,midC,DTMF2)   ;  //Set Sound DTMF2 when Press key"2"
    1926:	84 e6       	ldi	r24, 0x64	; 100
    1928:	60 e0       	ldi	r22, 0x00	; 0
    192a:	70 e0       	ldi	r23, 0x00	; 0
    192c:	42 e3       	ldi	r20, 0x32	; 50
    192e:	50 e0       	ldi	r21, 0x00	; 0
    1930:	0e 94 71 02 	call	0x4e2	; 0x4e2 <Sound_Effect>
             Update_Screen(Green,bt)        ;  //Update Screen
    1934:	60 e0       	ldi	r22, 0x00	; 0
    1936:	7f ef       	ldi	r23, 0xFF	; 255
    1938:	80 e0       	ldi	r24, 0x00	; 0
    193a:	90 e0       	ldi	r25, 0x00	; 0
    193c:	a7 01       	movw	r20, r14
    193e:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>
          
           } 

             //------Y-Touch Key"5"------//

           if((tc_y>124)&(tc_y<164))            //Check Position Touch Y-axis for Key"5"
    1942:	80 91 44 01 	lds	r24, 0x0144
    1946:	90 91 45 01 	lds	r25, 0x0145
    194a:	8d 57       	subi	r24, 0x7D	; 125
    194c:	90 40       	sbci	r25, 0x00	; 0
    194e:	87 97       	sbiw	r24, 0x27	; 39
    1950:	b0 f4       	brcc	.+44     	; 0x197e <User_App+0x22c>
            {  
              if(num < 10)                      //Check Number Charecter limit display text 10 Charecter
    1952:	0a 30       	cpi	r16, 0x0A	; 10
    1954:	30 f4       	brcc	.+12     	; 0x1962 <User_App+0x210>
               {
                bt[num] = '5'               ;   //Set Text Key"5"
    1956:	f7 01       	movw	r30, r14
    1958:	e0 0f       	add	r30, r16
    195a:	f1 1d       	adc	r31, r1
    195c:	b5 e3       	ldi	r27, 0x35	; 53
    195e:	b0 83       	st	Z, r27
                num += 1                    ;   //Increment Number Text
    1960:	0f 5f       	subi	r16, 0xFF	; 255
               }
               
              Sound_Effect(100,midC,DTMF5)   ;  //Set Sound DTMF5 when Press key"5"
    1962:	84 e6       	ldi	r24, 0x64	; 100
    1964:	60 e0       	ldi	r22, 0x00	; 0
    1966:	70 e0       	ldi	r23, 0x00	; 0
    1968:	45 e3       	ldi	r20, 0x35	; 53
    196a:	50 e0       	ldi	r21, 0x00	; 0
    196c:	0e 94 71 02 	call	0x4e2	; 0x4e2 <Sound_Effect>
              Update_Screen(Green,bt)        ; 
    1970:	60 e0       	ldi	r22, 0x00	; 0
    1972:	7f ef       	ldi	r23, 0xFF	; 255
    1974:	80 e0       	ldi	r24, 0x00	; 0
    1976:	90 e0       	ldi	r25, 0x00	; 0
    1978:	a7 01       	movw	r20, r14
    197a:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>
            } 

        
             //------Y-Touch Key"8"------//

          if((tc_y>168)&(tc_y<208))           //Check Position Touch Y-axis for Key"8"
    197e:	80 91 44 01 	lds	r24, 0x0144
    1982:	90 91 45 01 	lds	r25, 0x0145
    1986:	89 5a       	subi	r24, 0xA9	; 169
    1988:	90 40       	sbci	r25, 0x00	; 0
    198a:	87 97       	sbiw	r24, 0x27	; 39
    198c:	b0 f4       	brcc	.+44     	; 0x19ba <User_App+0x268>
          {  
            if(num < 10)                      //Check Number Charecter limit display text 10 Charecter
    198e:	0a 30       	cpi	r16, 0x0A	; 10
    1990:	30 f4       	brcc	.+12     	; 0x199e <User_App+0x24c>
             {
               bt[num] = '8'               ;  //Set Text Key"8"
    1992:	f7 01       	movw	r30, r14
    1994:	e0 0f       	add	r30, r16
    1996:	f1 1d       	adc	r31, r1
    1998:	88 e3       	ldi	r24, 0x38	; 56
    199a:	80 83       	st	Z, r24
               num += 1                    ;  //Increment Number Text
    199c:	0f 5f       	subi	r16, 0xFF	; 255
             }
               
            Sound_Effect(100,midC,DTMF8)   ;  //Set Sound DTMF8 when Press key"8"
    199e:	84 e6       	ldi	r24, 0x64	; 100
    19a0:	60 e0       	ldi	r22, 0x00	; 0
    19a2:	70 e0       	ldi	r23, 0x00	; 0
    19a4:	48 e3       	ldi	r20, 0x38	; 56
    19a6:	50 e0       	ldi	r21, 0x00	; 0
    19a8:	0e 94 71 02 	call	0x4e2	; 0x4e2 <Sound_Effect>
            Update_Screen(Green,bt)        ; 
    19ac:	60 e0       	ldi	r22, 0x00	; 0
    19ae:	7f ef       	ldi	r23, 0xFF	; 255
    19b0:	80 e0       	ldi	r24, 0x00	; 0
    19b2:	90 e0       	ldi	r25, 0x00	; 0
    19b4:	a7 01       	movw	r20, r14
    19b6:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>
              
          } 

               //------Y-Touch Key"0"------//

         if((tc_y>212)&(tc_y<252))            //Check Position Touch Y-axis for Key"0"
    19ba:	80 91 44 01 	lds	r24, 0x0144
    19be:	90 91 45 01 	lds	r25, 0x0145
    19c2:	85 5d       	subi	r24, 0xD5	; 213
    19c4:	90 40       	sbci	r25, 0x00	; 0
    19c6:	87 97       	sbiw	r24, 0x27	; 39
    19c8:	a8 f4       	brcc	.+42     	; 0x19f4 <User_App+0x2a2>
          {  
            if(num < 10)                      //Check Number Charecter limit display text 10 Charecter
    19ca:	0a 30       	cpi	r16, 0x0A	; 10
    19cc:	28 f4       	brcc	.+10     	; 0x19d8 <User_App+0x286>
             {
               bt[num] = '0'               ;  //Set Text Key"0"
    19ce:	f7 01       	movw	r30, r14
    19d0:	e0 0f       	add	r30, r16
    19d2:	f1 1d       	adc	r31, r1
    19d4:	20 82       	st	Z, r2
               num += 1                    ;  //Increment Number Text
    19d6:	0f 5f       	subi	r16, 0xFF	; 255
             }
               
            Sound_Effect(100,midC,DTMF0)   ;  //Set Sound DTMF0 when Press key"0"
    19d8:	84 e6       	ldi	r24, 0x64	; 100
    19da:	60 e0       	ldi	r22, 0x00	; 0
    19dc:	70 e0       	ldi	r23, 0x00	; 0
    19de:	40 e3       	ldi	r20, 0x30	; 48
    19e0:	50 e0       	ldi	r21, 0x00	; 0
    19e2:	0e 94 71 02 	call	0x4e2	; 0x4e2 <Sound_Effect>
            Update_Screen(Green,bt)        ; 
    19e6:	60 e0       	ldi	r22, 0x00	; 0
    19e8:	7f ef       	ldi	r23, 0xFF	; 255
    19ea:	80 e0       	ldi	r24, 0x00	; 0
    19ec:	90 e0       	ldi	r25, 0x00	; 0
    19ee:	a7 01       	movw	r20, r14
    19f0:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>
        
       //----------------------Check Key"3,6,9,#"------------------------//

           //X-Touch Button "3,6,9,#"

       if((tc_x>371) & (tc_x <425))            //Check Position Touch X-axis for Key"3,6,9,#"
    19f4:	80 91 42 01 	lds	r24, 0x0142
    19f8:	90 91 43 01 	lds	r25, 0x0143
    19fc:	84 57       	subi	r24, 0x74	; 116
    19fe:	91 40       	sbci	r25, 0x01	; 1
    1a00:	c5 97       	sbiw	r24, 0x35	; 53
    1a02:	08 f0       	brcs	.+2      	; 0x1a06 <User_App+0x2b4>
    1a04:	75 c0       	rjmp	.+234    	; 0x1af0 <User_App+0x39e>
         { 
          //----Y-Touch Key"3"-----//

           if((tc_y>80)&(tc_y<120))                //Check Position Touch Y-axis for key"3"
    1a06:	80 91 44 01 	lds	r24, 0x0144
    1a0a:	90 91 45 01 	lds	r25, 0x0145
    1a0e:	81 55       	subi	r24, 0x51	; 81
    1a10:	90 40       	sbci	r25, 0x00	; 0
    1a12:	87 97       	sbiw	r24, 0x27	; 39
    1a14:	a8 f4       	brcc	.+42     	; 0x1a40 <User_App+0x2ee>
           {      
            if(num < 10)                           //Check Number Charecter limit display text 10 Charecter
    1a16:	0a 30       	cpi	r16, 0x0A	; 10
    1a18:	28 f4       	brcc	.+10     	; 0x1a24 <User_App+0x2d2>
             {
               bt[num] = '3'                   ;  //Set Text key "3"
    1a1a:	f7 01       	movw	r30, r14
    1a1c:	e0 0f       	add	r30, r16
    1a1e:	f1 1d       	adc	r31, r1
    1a20:	30 82       	st	Z, r3
               num += 1                        ;  //Increment Number Text
    1a22:	0f 5f       	subi	r16, 0xFF	; 255
             }

             Sound_Effect(100,midC,DTMF3)      ;  //Set Sound DTMF3 when Press key"3"
    1a24:	84 e6       	ldi	r24, 0x64	; 100
    1a26:	60 e0       	ldi	r22, 0x00	; 0
    1a28:	70 e0       	ldi	r23, 0x00	; 0
    1a2a:	43 e3       	ldi	r20, 0x33	; 51
    1a2c:	50 e0       	ldi	r21, 0x00	; 0
    1a2e:	0e 94 71 02 	call	0x4e2	; 0x4e2 <Sound_Effect>
             Update_Screen(Green,bt)           ;  //Update Screen
    1a32:	60 e0       	ldi	r22, 0x00	; 0
    1a34:	7f ef       	ldi	r23, 0xFF	; 255
    1a36:	80 e0       	ldi	r24, 0x00	; 0
    1a38:	90 e0       	ldi	r25, 0x00	; 0
    1a3a:	a7 01       	movw	r20, r14
    1a3c:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>
          
           }   

             //------Y-Touch Key"6"------//

          if((tc_y>124)&(tc_y<164))               //Check Position Touch Y-axis for Key"6"
    1a40:	80 91 44 01 	lds	r24, 0x0144
    1a44:	90 91 45 01 	lds	r25, 0x0145
    1a48:	8d 57       	subi	r24, 0x7D	; 125
    1a4a:	90 40       	sbci	r25, 0x00	; 0
    1a4c:	87 97       	sbiw	r24, 0x27	; 39
    1a4e:	a8 f4       	brcc	.+42     	; 0x1a7a <User_App+0x328>
          {  
           if(num < 10)                           //Check Number Charecter limit display text 10 Charecter
    1a50:	0a 30       	cpi	r16, 0x0A	; 10
    1a52:	28 f4       	brcc	.+10     	; 0x1a5e <User_App+0x30c>
             {
               bt[num] = '6'                  ;   //Set Text Key"6"
    1a54:	f7 01       	movw	r30, r14
    1a56:	e0 0f       	add	r30, r16
    1a58:	f1 1d       	adc	r31, r1
    1a5a:	40 82       	st	Z, r4
               num += 1                       ;   //Increment Number Text
    1a5c:	0f 5f       	subi	r16, 0xFF	; 255
             }
               
           Sound_Effect(100,midC,DTMF6)      ;   //Set Sound DTMF6 when Press key"6"
    1a5e:	84 e6       	ldi	r24, 0x64	; 100
    1a60:	60 e0       	ldi	r22, 0x00	; 0
    1a62:	70 e0       	ldi	r23, 0x00	; 0
    1a64:	46 e3       	ldi	r20, 0x36	; 54
    1a66:	50 e0       	ldi	r21, 0x00	; 0
    1a68:	0e 94 71 02 	call	0x4e2	; 0x4e2 <Sound_Effect>
           Update_Screen(Green,bt)           ; 
    1a6c:	60 e0       	ldi	r22, 0x00	; 0
    1a6e:	7f ef       	ldi	r23, 0xFF	; 255
    1a70:	80 e0       	ldi	r24, 0x00	; 0
    1a72:	90 e0       	ldi	r25, 0x00	; 0
    1a74:	a7 01       	movw	r20, r14
    1a76:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>
         } 

        
             //------Y-Touch Key"9"------//

         if((tc_y>168)&(tc_y<208))               //Check Position Touch Y-axis for Key"9"
    1a7a:	80 91 44 01 	lds	r24, 0x0144
    1a7e:	90 91 45 01 	lds	r25, 0x0145
    1a82:	89 5a       	subi	r24, 0xA9	; 169
    1a84:	90 40       	sbci	r25, 0x00	; 0
    1a86:	87 97       	sbiw	r24, 0x27	; 39
    1a88:	a8 f4       	brcc	.+42     	; 0x1ab4 <User_App+0x362>
          {  
            if(num < 10)                         //Check Number Charecter limit display text 10 Charecter
    1a8a:	0a 30       	cpi	r16, 0x0A	; 10
    1a8c:	28 f4       	brcc	.+10     	; 0x1a98 <User_App+0x346>
             {
              bt[num] = '9'                    ;   //Set Text Key"9"
    1a8e:	f7 01       	movw	r30, r14
    1a90:	e0 0f       	add	r30, r16
    1a92:	f1 1d       	adc	r31, r1
    1a94:	50 82       	st	Z, r5
               num    += 1                     ;   //Increment Number Text 
    1a96:	0f 5f       	subi	r16, 0xFF	; 255
             }

             Sound_Effect(100,midC,DTMF9)      ;  //Set Sound DTMF8 when Press key"9"
    1a98:	84 e6       	ldi	r24, 0x64	; 100
    1a9a:	60 e0       	ldi	r22, 0x00	; 0
    1a9c:	70 e0       	ldi	r23, 0x00	; 0
    1a9e:	49 e3       	ldi	r20, 0x39	; 57
    1aa0:	50 e0       	ldi	r21, 0x00	; 0
    1aa2:	0e 94 71 02 	call	0x4e2	; 0x4e2 <Sound_Effect>
             Update_Screen(Green,bt)           ; 
    1aa6:	60 e0       	ldi	r22, 0x00	; 0
    1aa8:	7f ef       	ldi	r23, 0xFF	; 255
    1aaa:	80 e0       	ldi	r24, 0x00	; 0
    1aac:	90 e0       	ldi	r25, 0x00	; 0
    1aae:	a7 01       	movw	r20, r14
    1ab0:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>
              
          } 

               //------Y-Touch Key"#"------//

         if((tc_y>212)&(tc_y<252))               //Check Position Touch Y-axis for Key"#"
    1ab4:	80 91 44 01 	lds	r24, 0x0144
    1ab8:	90 91 45 01 	lds	r25, 0x0145
    1abc:	85 5d       	subi	r24, 0xD5	; 213
    1abe:	90 40       	sbci	r25, 0x00	; 0
    1ac0:	87 97       	sbiw	r24, 0x27	; 39
    1ac2:	b0 f4       	brcc	.+44     	; 0x1af0 <User_App+0x39e>
          {  
           if(num < 10)                          //Check Number Charecter limit display text 10 Charecter
    1ac4:	0a 30       	cpi	r16, 0x0A	; 10
    1ac6:	30 f4       	brcc	.+12     	; 0x1ad4 <User_App+0x382>
             {
               bt[num] = '#'                  ;  //Set Text Key"#"
    1ac8:	f7 01       	movw	r30, r14
    1aca:	e0 0f       	add	r30, r16
    1acc:	f1 1d       	adc	r31, r1
    1ace:	a3 e2       	ldi	r26, 0x23	; 35
    1ad0:	a0 83       	st	Z, r26
               num += 1                       ;  //Increment Number Text
    1ad2:	0f 5f       	subi	r16, 0xFF	; 255
             }
               
           Sound_Effect(100,midC,DTMF_shap)   ;  //Set Sound DTMF# when Press key"#"
    1ad4:	84 e6       	ldi	r24, 0x64	; 100
    1ad6:	60 e0       	ldi	r22, 0x00	; 0
    1ad8:	70 e0       	ldi	r23, 0x00	; 0
    1ada:	43 e2       	ldi	r20, 0x23	; 35
    1adc:	50 e0       	ldi	r21, 0x00	; 0
    1ade:	0e 94 71 02 	call	0x4e2	; 0x4e2 <Sound_Effect>
           Update_Screen(Green,bt)            ; 
    1ae2:	60 e0       	ldi	r22, 0x00	; 0
    1ae4:	7f ef       	ldi	r23, 0xFF	; 255
    1ae6:	80 e0       	ldi	r24, 0x00	; 0
    1ae8:	90 e0       	ldi	r25, 0x00	; 0
    1aea:	a7 01       	movw	r20, r14
    1aec:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>

        //----------------------Check Key"C"------------------------//

          //X-Touch Key"C"

        if((tc_x>85) & (tc_x <205))               //Check Position Touch X-axis for Key"C"
    1af0:	80 91 42 01 	lds	r24, 0x0142
    1af4:	90 91 43 01 	lds	r25, 0x0143
    1af8:	86 55       	subi	r24, 0x56	; 86
    1afa:	90 40       	sbci	r25, 0x00	; 0
    1afc:	87 37       	cpi	r24, 0x77	; 119
    1afe:	91 05       	cpc	r25, r1
    1b00:	f0 f4       	brcc	.+60     	; 0x1b3e <User_App+0x3ec>
         { 
          //Y-Touch Key"C"//
           if((tc_y>150)&(tc_y<230))              //Check Position Touch Y-axis for key "C"
    1b02:	80 91 44 01 	lds	r24, 0x0144
    1b06:	90 91 45 01 	lds	r25, 0x0145
    1b0a:	87 59       	subi	r24, 0x97	; 151
    1b0c:	90 40       	sbci	r25, 0x00	; 0
    1b0e:	8f 34       	cpi	r24, 0x4F	; 79
    1b10:	91 05       	cpc	r25, r1
    1b12:	a8 f4       	brcc	.+42     	; 0x1b3e <User_App+0x3ec>
    1b14:	f7 01       	movw	r30, r14
            {
               
              for(num=0;num<10;num++)       
                bt[num] = ' '                 ;   //Clear Buffer keep Text = Blank  
    1b16:	b0 e2       	ldi	r27, 0x20	; 32
    1b18:	b1 93       	st	Z+, r27
         { 
          //Y-Touch Key"C"//
           if((tc_y>150)&(tc_y<230))              //Check Position Touch Y-axis for key "C"
            {
               
              for(num=0;num<10;num++)       
    1b1a:	ec 15       	cp	r30, r12
    1b1c:	fd 05       	cpc	r31, r13
    1b1e:	d9 f7       	brne	.-10     	; 0x1b16 <User_App+0x3c4>
                bt[num] = ' '                 ;   //Clear Buffer keep Text = Blank  
         
              num = 0                         ;   //Set pointer array New start =0
 
              Sound_Effect(100,midC,Switch)   ;   //Set Sound DTMF1 when Press key"C"
    1b20:	84 e6       	ldi	r24, 0x64	; 100
    1b22:	60 e0       	ldi	r22, 0x00	; 0
    1b24:	70 e0       	ldi	r23, 0x00	; 0
    1b26:	41 e5       	ldi	r20, 0x51	; 81
    1b28:	50 e0       	ldi	r21, 0x00	; 0
    1b2a:	0e 94 71 02 	call	0x4e2	; 0x4e2 <Sound_Effect>
              Update_Screen(Green,bt)         ;   //Update Screen
    1b2e:	60 e0       	ldi	r22, 0x00	; 0
    1b30:	7f ef       	ldi	r23, 0xFF	; 255
    1b32:	80 e0       	ldi	r24, 0x00	; 0
    1b34:	90 e0       	ldi	r25, 0x00	; 0
    1b36:	a7 01       	movw	r20, r14
    1b38:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>
    1b3c:	00 e0       	ldi	r16, 0x00	; 0
          }   //if tc_x  key "C"


         //---------------------- Check Release Key -----------------------//
        
        while(Touch_Detect()){;}             //Check Release Touch button
    1b3e:	0e 94 50 02 	call	0x4a0	; 0x4a0 <Touch_Detect>
    1b42:	88 23       	and	r24, r24
    1b44:	e1 f7       	brne	.-8      	; 0x1b3e <User_App+0x3ec>
    1b46:	84 e6       	ldi	r24, 0x64	; 100
    1b48:	90 e0       	ldi	r25, 0x00	; 0
    1b4a:	f5 01       	movw	r30, r10
    1b4c:	31 97       	sbiw	r30, 0x01	; 1
    1b4e:	f1 f7       	brne	.-4      	; 0x1b4c <User_App+0x3fa>
 ++                                                ++
 +++++++++++++++++++++++++++++++++++++++++++++++++++*/

 void delay_ms(unsigned int cnt)
  {
    for(;cnt>0;cnt--)
    1b50:	01 97       	sbiw	r24, 0x01	; 1
    1b52:	d9 f7       	brne	.-10     	; 0x1b4a <User_App+0x3f8>

         //---------------------- Check Release Key -----------------------//
        
        while(Touch_Detect()){;}             //Check Release Touch button
        delay_ms(100);
        Sound_Effect(100,midC,Silence) ;     //Stop Sound DTMF
    1b54:	84 e6       	ldi	r24, 0x64	; 100
    1b56:	60 e0       	ldi	r22, 0x00	; 0
    1b58:	70 e0       	ldi	r23, 0x00	; 0
    1b5a:	40 e0       	ldi	r20, 0x00	; 0
    1b5c:	50 e0       	ldi	r21, 0x00	; 0
    1b5e:	0e 94 71 02 	call	0x4e2	; 0x4e2 <Sound_Effect>
        Update_Screen(Black,bt)        ;     //Up date Screen 
    1b62:	60 e0       	ldi	r22, 0x00	; 0
    1b64:	70 e0       	ldi	r23, 0x00	; 0
    1b66:	80 e0       	ldi	r24, 0x00	; 0
    1b68:	90 e0       	ldi	r25, 0x00	; 0
    1b6a:	a7 01       	movw	r20, r14
    1b6c:	0e 94 9c 0a 	call	0x1538	; 0x1538 <Update_Screen>
    1b70:	3f ce       	rjmp	.-898    	; 0x17f0 <User_App+0x9e>

00001b72 <main>:
  +++++++++++++++++++++++++++++++++++++++++++++++++++*/

 void init_port(void)
  {

   DDRB  = 0x5E     ;        //Set PB1[MOSI],PB2[SCK],PB3[CS],PB4[PD#],PB6[SD_CS] = Output ; PB0[MISO],PB5(INT)=Input
    1b72:	8e e5       	ldi	r24, 0x5E	; 94
    1b74:	87 bb       	out	0x17, r24	; 23
   
   //------ Set Value Default Port ------ 
         
   PORTB = 0x7B     ;       //Set Default Port PB0(MISO),PB5(INT) = 1(Pull Up) ,PB4(PD)=1(Disable Power down),PB3(CS)=1, 
    1b76:	8b e7       	ldi	r24, 0x7B	; 123
    1b78:	88 bb       	out	0x18, r24	; 24

int main(void)
 {
  
   init_port()        ;
   FT800_Initial()   ;
    1b7a:	0e 94 12 09 	call	0x1224	; 0x1224 <FT800_Initial>
   Touch_Calibrate() ;
    1b7e:	0e 94 ab 05 	call	0xb56	; 0xb56 <Touch_Calibrate>
   User_App()        ;
    1b82:	0e 94 a9 0b 	call	0x1752	; 0x1752 <User_App>

}
    1b86:	80 e0       	ldi	r24, 0x00	; 0
    1b88:	90 e0       	ldi	r25, 0x00	; 0
    1b8a:	08 95       	ret

00001b8c <_exit>:
    1b8c:	f8 94       	cli

00001b8e <__stop_program>:
    1b8e:	ff cf       	rjmp	.-2      	; 0x1b8e <__stop_program>
