Subversion Repositories Projects

Rev

Blame | Last modification | View Log | RSS feed


main.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .data         000002d8  00800100  000011b8  0000124c  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  1 .text         000011b8  00000000  00000000  00000094  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  2 .bss          000000cc  008003d8  008003d8  00001524  2**0
                  ALLOC
  3 .stab         00000378  00000000  00000000  00001524  2**2
                  CONTENTS, READONLY, DEBUGGING
  4 .stabstr      00000071  00000000  00000000  0000189c  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_aranges 00000020  00000000  00000000  0000190d  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_pubnames 00000207  00000000  00000000  0000192d  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_info   000007c7  00000000  00000000  00001b34  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_abbrev 0000020c  00000000  00000000  000022fb  2**0
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_line   00000d5d  00000000  00000000  00002507  2**0
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_frame  000000a0  00000000  00000000  00003264  2**2
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_str    00000287  00000000  00000000  00003304  2**0
                  CONTENTS, READONLY, DEBUGGING
 12 .debug_loc    00000453  00000000  00000000  0000358b  2**0
                  CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:

00000000 <__vectors>:
       0:       19 c0           rjmp    .+50            ; 0x34 <__ctors_end>
       2:       70 c8           rjmp    .-3872          ; 0xfffff0e4 <__eeprom_end+0xff7ef0e4>
       4:       9c c8           rjmp    .-3784          ; 0xfffff13e <__eeprom_end+0xff7ef13e>
       6:       31 c0           rjmp    .+98            ; 0x6a <__bad_interrupt>
       8:       30 c0           rjmp    .+96            ; 0x6a <__bad_interrupt>
       a:       2f c0           rjmp    .+94            ; 0x6a <__bad_interrupt>
       c:       2e c0           rjmp    .+92            ; 0x6a <__bad_interrupt>
       e:       2d c0           rjmp    .+90            ; 0x6a <__bad_interrupt>
      10:       2c c0           rjmp    .+88            ; 0x6a <__bad_interrupt>
      12:       2b c0           rjmp    .+86            ; 0x6a <__bad_interrupt>
      14:       2a c0           rjmp    .+84            ; 0x6a <__bad_interrupt>
      16:       29 c0           rjmp    .+82            ; 0x6a <__bad_interrupt>
      18:       28 c0           rjmp    .+80            ; 0x6a <__bad_interrupt>
      1a:       27 c0           rjmp    .+78            ; 0x6a <__bad_interrupt>
      1c:       26 c0           rjmp    .+76            ; 0x6a <__bad_interrupt>
      1e:       25 c0           rjmp    .+74            ; 0x6a <__bad_interrupt>
      20:       24 c0           rjmp    .+72            ; 0x6a <__bad_interrupt>
      22:       23 c0           rjmp    .+70            ; 0x6a <__bad_interrupt>
      24:       22 c0           rjmp    .+68            ; 0x6a <__bad_interrupt>
      26:       21 c0           rjmp    .+66            ; 0x6a <__bad_interrupt>
      28:       20 c0           rjmp    .+64            ; 0x6a <__bad_interrupt>
      2a:       1f c0           rjmp    .+62            ; 0x6a <__bad_interrupt>
      2c:       1e c0           rjmp    .+60            ; 0x6a <__bad_interrupt>
      2e:       1d c0           rjmp    .+58            ; 0x6a <__bad_interrupt>
      30:       1c c0           rjmp    .+56            ; 0x6a <__bad_interrupt>
      32:       1b c0           rjmp    .+54            ; 0x6a <__bad_interrupt>

00000034 <__ctors_end>:
      34:       11 24           eor     r1, r1
      36:       1f be           out     0x3f, r1        ; 63
      38:       cf ef           ldi     r28, 0xFF       ; 255
      3a:       d4 e0           ldi     r29, 0x04       ; 4
      3c:       de bf           out     0x3e, r29       ; 62
      3e:       cd bf           out     0x3d, r28       ; 61

00000040 <__do_copy_data>:
      40:       13 e0           ldi     r17, 0x03       ; 3
      42:       a0 e0           ldi     r26, 0x00       ; 0
      44:       b1 e0           ldi     r27, 0x01       ; 1
      46:       e8 eb           ldi     r30, 0xB8       ; 184
      48:       f1 e1           ldi     r31, 0x11       ; 17
      4a:       02 c0           rjmp    .+4             ; 0x50 <.do_copy_data_start>

0000004c <.do_copy_data_loop>:
      4c:       05 90           lpm     r0, Z+
      4e:       0d 92           st      X+, r0

00000050 <.do_copy_data_start>:
      50:       a8 3d           cpi     r26, 0xD8       ; 216
      52:       b1 07           cpc     r27, r17
      54:       d9 f7           brne    .-10            ; 0x4c <.do_copy_data_loop>

00000056 <__do_clear_bss>:
      56:       14 e0           ldi     r17, 0x04       ; 4
      58:       a8 ed           ldi     r26, 0xD8       ; 216
      5a:       b3 e0           ldi     r27, 0x03       ; 3
      5c:       01 c0           rjmp    .+2             ; 0x60 <.do_clear_bss_start>

0000005e <.do_clear_bss_loop>:
      5e:       1d 92           st      X+, r1

00000060 <.do_clear_bss_start>:
      60:       a4 3a           cpi     r26, 0xA4       ; 164
      62:       b1 07           cpc     r27, r17
      64:       e1 f7           brne    .-8             ; 0x5e <.do_clear_bss_loop>
      66:       f6 d1           rcall   .+1004          ; 0x454 <main>
      68:       a6 c8           rjmp    .-3764          ; 0xfffff1b6 <__eeprom_end+0xff7ef1b6>

0000006a <__bad_interrupt>:
      6a:       ca cf           rjmp    .-108           ; 0x0 <__vectors>

0000006c <GR_Copy>:
//-----------------------------------------------------------------------------
// copy bitmap
//-----------------------------------------------------------------------------
extern void GR_Copy(unsigned char* source,int start,int max)
{
      6c:       dc 01           movw    r26, r24
        int i;
        for(i=0;i<max;i++) 
      6e:       14 16           cp      r1, r20
      70:       15 06           cpc     r1, r21
      72:       64 f4           brge    .+24            ; 0x8c <GR_Copy+0x20>
      74:       fb 01           movw    r30, r22
      76:       e9 5c           subi    r30, 0xC9       ; 201
      78:       fe 4f           sbci    r31, 0xFE       ; 254
      7a:       20 e0           ldi     r18, 0x00       ; 0
      7c:       30 e0           ldi     r19, 0x00       ; 0
        {
          dmem[start+i]=*source;
      7e:       8d 91           ld      r24, X+
      80:       81 93           st      Z+, r24
      82:       2f 5f           subi    r18, 0xFF       ; 255
      84:       3f 4f           sbci    r19, 0xFF       ; 255
      86:       42 17           cp      r20, r18
      88:       53 07           cpc     r21, r19
      8a:       c9 f7           brne    .-14            ; 0x7e <GR_Copy+0x12>
      8c:       08 95           ret

0000008e <GR_Clear>:
          source++;
        }
}

//-----------------------------------------------------------------------------
// Clear Graphic Area 
//-----------------------------------------------------------------------------
extern void GR_Clear()
{
      8e:       e7 e3           ldi     r30, 0x37       ; 55
      90:       f1 e0           ldi     r31, 0x01       ; 1
      92:       8f e4           ldi     r24, 0x4F       ; 79
      94:       92 e0           ldi     r25, 0x02       ; 2
        int i; 
        for(i=0;i<GR_MaxGraph;i++)
        {
                dmem[i]=0;
      96:       11 92           st      Z+, r1
      98:       e8 17           cp      r30, r24
      9a:       f9 07           cpc     r31, r25
      9c:       e1 f7           brne    .-8             ; 0x96 <GR_Clear+0x8>
      9e:       08 95           ret

000000a0 <Decode64>:
        }
}

//-----------------------------------------------------------------------------
// Show and Hide Graphic area and Background 
//-----------------------------------------------------------------------------
#define SHOWGRAPHIC     showgraphic=1
#define HIDEGRAPHIC             showgraphic=0
#define SHOWGRAPHICBACK showgraphicb=1
#define HIDEGRAPHICBACK showgraphicb=0


//-----------------------------------------------------------------------------
// Decode64 
//-----------------------------------------------------------------------------
extern void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max)  
{
      a0:       ef 92           push    r14
      a2:       ff 92           push    r15
      a4:       1f 93           push    r17
      a6:       cf 93           push    r28
      a8:       df 93           push    r29
      aa:       ec 01           movw    r28, r24
      ac:       16 2f           mov     r17, r22
        unsigned char a,b,c,d;
        unsigned char ptr = 0;
        unsigned char x,y,z;
        while(len)
      ae:       66 23           and     r22, r22
      b0:       09 f4           brne    .+2             ; 0xb4 <Decode64+0x14>
      b2:       7b c0           rjmp    .+246           ; 0x1aa <Decode64+0x10a>
        {
                a = RxdBuffer[ptrIn++] - '=';
      b4:       a4 ef           ldi     r26, 0xF4       ; 244
      b6:       b3 e0           ldi     r27, 0x03       ; 3
      b8:       fd 01           movw    r30, r26
      ba:       e4 0f           add     r30, r20
      bc:       f1 1d           adc     r31, r1
      be:       50 81           ld      r21, Z
      c0:       84 2f           mov     r24, r20
      c2:       8f 5f           subi    r24, 0xFF       ; 255
                b = RxdBuffer[ptrIn++] - '=';
      c4:       fd 01           movw    r30, r26
      c6:       e8 0f           add     r30, r24
      c8:       f1 1d           adc     r31, r1
      ca:       30 81           ld      r19, Z
      cc:       8f 5f           subi    r24, 0xFF       ; 255
                c = RxdBuffer[ptrIn++] - '=';
      ce:       fd 01           movw    r30, r26
      d0:       e8 0f           add     r30, r24
      d2:       f1 1d           adc     r31, r1
      d4:       e0 81           ld      r30, Z
      d6:       8f 5f           subi    r24, 0xFF       ; 255
                d = RxdBuffer[ptrIn++] - '=';
      d8:       a8 0f           add     r26, r24
      da:       b1 1d           adc     r27, r1
      dc:       ac 91           ld      r26, X
      de:       4c 5f           subi    r20, 0xFC       ; 252
                if(ptrIn > max - 2) break;     
      e0:       82 2f           mov     r24, r18
      e2:       99 27           eor     r25, r25
      e4:       0f 2e           mov     r0, r31
      e6:       fe ef           ldi     r31, 0xFE       ; 254
      e8:       ef 2e           mov     r14, r31
      ea:       ff ef           ldi     r31, 0xFF       ; 255
      ec:       ff 2e           mov     r15, r31
      ee:       f0 2d           mov     r31, r0
      f0:       e8 0e           add     r14, r24
      f2:       f9 1e           adc     r15, r25
      f4:       84 2f           mov     r24, r20
      f6:       99 27           eor     r25, r25
      f8:       e8 16           cp      r14, r24
      fa:       f9 06           cpc     r15, r25
      fc:       0c f4           brge    .+2             ; 0x100 <Decode64+0x60>
      fe:       55 c0           rjmp    .+170           ; 0x1aa <Decode64+0x10a>
     100:       85 2f           mov     r24, r21
     102:       8d 53           subi    r24, 0x3D       ; 61
     104:       3d 53           subi    r19, 0x3D       ; 61
     106:       5e 2f           mov     r21, r30
     108:       5d 53           subi    r21, 0x3D       ; 61
     10a:       ad 53           subi    r26, 0x3D       ; 61
     10c:       20 e0           ldi     r18, 0x00       ; 0
     10e:       64 ef           ldi     r22, 0xF4       ; 244
     110:       73 e0           ldi     r23, 0x03       ; 3
     112:       20 c0           rjmp    .+64            ; 0x154 <Decode64+0xb4>
     114:       fb 01           movw    r30, r22
     116:       e4 0f           add     r30, r20
     118:       f1 1d           adc     r31, r1
     11a:       b0 81           ld      r27, Z
     11c:       84 2f           mov     r24, r20
     11e:       8f 5f           subi    r24, 0xFF       ; 255
     120:       fb 01           movw    r30, r22
     122:       e8 0f           add     r30, r24
     124:       f1 1d           adc     r31, r1
     126:       30 81           ld      r19, Z
     128:       8f 5f           subi    r24, 0xFF       ; 255
     12a:       fb 01           movw    r30, r22
     12c:       e8 0f           add     r30, r24
     12e:       f1 1d           adc     r31, r1
     130:       50 81           ld      r21, Z
     132:       8f 5f           subi    r24, 0xFF       ; 255
     134:       fb 01           movw    r30, r22
     136:       e8 0f           add     r30, r24
     138:       f1 1d           adc     r31, r1
     13a:       a0 81           ld      r26, Z
     13c:       4c 5f           subi    r20, 0xFC       ; 252
     13e:       84 2f           mov     r24, r20
     140:       99 27           eor     r25, r25
     142:       e8 16           cp      r14, r24
     144:       f9 06           cpc     r15, r25
     146:       8c f1           brlt    .+98            ; 0x1aa <Decode64+0x10a>
     148:       8b 2f           mov     r24, r27
     14a:       8d 53           subi    r24, 0x3D       ; 61
     14c:       3d 53           subi    r19, 0x3D       ; 61
     14e:       5d 53           subi    r21, 0x3D       ; 61
     150:       ad 53           subi    r26, 0x3D       ; 61
     152:       2d 5f           subi    r18, 0xFD       ; 253

                x = (a << 2) | (b >> 4);
                y = ((b & 0x0f) << 4) | (c >> 2);
                z = ((c & 0x03) << 6) | d;

                if(len--) ptrOut[ptr++] = x; else break;
     154:       fe 01           movw    r30, r28
     156:       e2 0f           add     r30, r18
     158:       f1 1d           adc     r31, r1
     15a:       88 0f           add     r24, r24
     15c:       88 0f           add     r24, r24
     15e:       93 2f           mov     r25, r19
     160:       92 95           swap    r25
     162:       9f 70           andi    r25, 0x0F       ; 15
     164:       89 2b           or      r24, r25
     166:       80 83           st      Z, r24
                if(len--) ptrOut[ptr++] = y; else break;
     168:       11 30           cpi     r17, 0x01       ; 1
     16a:       f9 f0           breq    .+62            ; 0x1aa <Decode64+0x10a>
     16c:       82 2f           mov     r24, r18
     16e:       8f 5f           subi    r24, 0xFF       ; 255
     170:       fe 01           movw    r30, r28
     172:       e8 0f           add     r30, r24
     174:       f1 1d           adc     r31, r1
     176:       83 2f           mov     r24, r19
     178:       82 95           swap    r24
     17a:       80 7f           andi    r24, 0xF0       ; 240
     17c:       95 2f           mov     r25, r21
     17e:       96 95           lsr     r25
     180:       96 95           lsr     r25
     182:       89 2b           or      r24, r25
     184:       80 83           st      Z, r24
     186:       13 50           subi    r17, 0x03       ; 3
                if(len--) ptrOut[ptr++] = z; else break;
     188:       1f 3f           cpi     r17, 0xFF       ; 255
     18a:       79 f0           breq    .+30            ; 0x1aa <Decode64+0x10a>
     18c:       82 2f           mov     r24, r18
     18e:       8e 5f           subi    r24, 0xFE       ; 254
     190:       fe 01           movw    r30, r28
     192:       e8 0f           add     r30, r24
     194:       f1 1d           adc     r31, r1
     196:       85 2f           mov     r24, r21
     198:       82 95           swap    r24
     19a:       88 0f           add     r24, r24
     19c:       88 0f           add     r24, r24
     19e:       80 7c           andi    r24, 0xC0       ; 192
     1a0:       8a 2b           or      r24, r26
     1a2:       80 83           st      Z, r24
     1a4:       11 23           and     r17, r17
     1a6:       09 f0           breq    .+2             ; 0x1aa <Decode64+0x10a>
     1a8:       b5 cf           rjmp    .-150           ; 0x114 <Decode64+0x74>
     1aa:       df 91           pop     r29
     1ac:       cf 91           pop     r28
     1ae:       1f 91           pop     r17
     1b0:       ff 90           pop     r15
     1b2:       ef 90           pop     r14
     1b4:       08 95           ret

000001b6 <process_rxdata>:
        }
}

//-----------------------------------------------------------------------------
// process RX Data 
//-----------------------------------------------------------------------------
extern void process_rxdata(unsigned char c)
{
     1b6:       80 93 e1 03     sts     0x03E1, r24
        static unsigned int crc;
        static unsigned char crc1,crc2,buf_ptr;
        static unsigned char UartState = 0;
        unsigned char CrcOkay = 0;

        SioTmp=c;

        if(buf_ptr >= MAX_RX_BUF)    
     1ba:       50 91 e6 03     lds     r21, 0x03E6
     1be:       54 36           cpi     r21, 0x64       ; 100
     1c0:       10 f0           brcs    .+4             ; 0x1c6 <process_rxdata+0x10>
                UartState = 0;
     1c2:       10 92 e5 03     sts     0x03E5, r1
        if(SioTmp == '\r' && UartState == 2) 
     1c6:       80 91 e1 03     lds     r24, 0x03E1
     1ca:       8d 30           cpi     r24, 0x0D       ; 13
     1cc:       09 f0           breq    .+2             ; 0x1d0 <process_rxdata+0x1a>
     1ce:       5c c0           rjmp    .+184           ; 0x288 <process_rxdata+0xd2>
     1d0:       80 91 e5 03     lds     r24, 0x03E5
     1d4:       82 30           cpi     r24, 0x02       ; 2
     1d6:       09 f0           breq    .+2             ; 0x1da <process_rxdata+0x24>
     1d8:       57 c0           rjmp    .+174           ; 0x288 <process_rxdata+0xd2>
        {
                UartState = 0;
     1da:       10 92 e5 03     sts     0x03E5, r1
                crc -= RxdBuffer[buf_ptr-2];
     1de:       65 2f           mov     r22, r21
     1e0:       77 27           eor     r23, r23
     1e2:       fb 01           movw    r30, r22
     1e4:       32 97           sbiw    r30, 0x02       ; 2
     1e6:       24 ef           ldi     r18, 0xF4       ; 244
     1e8:       33 e0           ldi     r19, 0x03       ; 3
     1ea:       e2 0f           add     r30, r18
     1ec:       f3 1f           adc     r31, r19
     1ee:       40 81           ld      r20, Z
                crc -= RxdBuffer[buf_ptr-1];
     1f0:       cb 01           movw    r24, r22
     1f2:       01 97           sbiw    r24, 0x01       ; 1
     1f4:       dc 01           movw    r26, r24
     1f6:       a2 0f           add     r26, r18
     1f8:       b3 1f           adc     r27, r19
     1fa:       2c 91           ld      r18, X
                crc %= 4096;
     1fc:       80 91 e9 03     lds     r24, 0x03E9
     200:       90 91 ea 03     lds     r25, 0x03EA
     204:       84 1b           sub     r24, r20
     206:       91 09           sbc     r25, r1
     208:       82 1b           sub     r24, r18
     20a:       91 09           sbc     r25, r1
     20c:       9f 70           andi    r25, 0x0F       ; 15
     20e:       90 93 ea 03     sts     0x03EA, r25
     212:       80 93 e9 03     sts     0x03E9, r24
                crc1 = '=' + crc / 64;
     216:       9c 01           movw    r18, r24
     218:       00 24           eor     r0, r0
     21a:       22 0f           add     r18, r18
     21c:       33 1f           adc     r19, r19
     21e:       00 1c           adc     r0, r0
     220:       22 0f           add     r18, r18
     222:       33 1f           adc     r19, r19
     224:       00 1c           adc     r0, r0
     226:       23 2f           mov     r18, r19
     228:       30 2d           mov     r19, r0
     22a:       23 5c           subi    r18, 0xC3       ; 195
     22c:       20 93 e8 03     sts     0x03E8, r18
                crc2 = '=' + crc % 64;
     230:       8f 73           andi    r24, 0x3F       ; 63
     232:       38 2f           mov     r19, r24
     234:       33 5c           subi    r19, 0xC3       ; 195
     236:       30 93 e7 03     sts     0x03E7, r19
                CrcOkay = 0;
                if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1]))
     23a:       80 81           ld      r24, Z
     23c:       28 17           cp      r18, r24
     23e:       29 f4           brne    .+10            ; 0x24a <process_rxdata+0x94>
     240:       8c 91           ld      r24, X
     242:       38 17           cp      r19, r24
     244:       11 f4           brne    .+4             ; 0x24a <process_rxdata+0x94>
     246:       91 e0           ldi     r25, 0x01       ; 1
     248:       09 c0           rjmp    .+18            ; 0x25c <process_rxdata+0xa6>
                {
                        CrcOkay = 1; 
                }
                else 
                { 
                        CrcOkay = 0; 
                        CntCrcError++;
     24a:       80 91 e3 03     lds     r24, 0x03E3
     24e:       8f 5f           subi    r24, 0xFF       ; 255
     250:       80 93 e3 03     sts     0x03E3, r24
                        display_line1[1]='E';
     254:       85 e4           ldi     r24, 0x45       ; 69
     256:       80 93 59 04     sts     0x0459, r24
     25a:       90 e0           ldi     r25, 0x00       ; 0

                }
                if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet
     25c:       80 91 e2 03     lds     r24, 0x03E2
     260:       88 23           and     r24, r24
     262:       09 f0           breq    .+2             ; 0x266 <process_rxdata+0xb0>
     264:       7e c0           rjmp    .+252           ; 0x362 <process_rxdata+0x1ac>
     266:       99 23           and     r25, r25
     268:       09 f4           brne    .+2             ; 0x26c <process_rxdata+0xb6>
     26a:       7b c0           rjmp    .+246           ; 0x362 <process_rxdata+0x1ac>
                {
                        NeuerDatensatzEmpfangen = 1; 
     26c:       81 e0           ldi     r24, 0x01       ; 1
     26e:       80 93 e2 03     sts     0x03E2, r24
                        AnzahlEmpfangsBytes = buf_ptr;
     272:       50 93 e4 03     sts     0x03E4, r21
                        RxdBuffer[buf_ptr] = '\r';
     276:       fb 01           movw    r30, r22
     278:       ec 50           subi    r30, 0x0C       ; 12
     27a:       fc 4f           sbci    r31, 0xFC       ; 252
     27c:       8d e0           ldi     r24, 0x0D       ; 13
     27e:       80 83           st      Z, r24
                        display_line1[1]='R';
     280:       82 e5           ldi     r24, 0x52       ; 82
     282:       80 93 59 04     sts     0x0459, r24
     286:       6d c0           rjmp    .+218           ; 0x362 <process_rxdata+0x1ac>
                }                                 
        }
        else
        switch(UartState)
     288:       80 91 e5 03     lds     r24, 0x03E5
     28c:       81 30           cpi     r24, 0x01       ; 1
     28e:       31 f1           breq    .+76            ; 0x2dc <process_rxdata+0x126>
     290:       81 30           cpi     r24, 0x01       ; 1
     292:       20 f0           brcs    .+8             ; 0x29c <process_rxdata+0xe6>
     294:       82 30           cpi     r24, 0x02       ; 2
     296:       09 f0           breq    .+2             ; 0x29a <process_rxdata+0xe4>
     298:       5f c0           rjmp    .+190           ; 0x358 <process_rxdata+0x1a2>
     29a:       3e c0           rjmp    .+124           ; 0x318 <process_rxdata+0x162>
        {
                case 0:
          if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1;  // Startzeichen und Daten schon verarbeitet
     29c:       80 91 e1 03     lds     r24, 0x03E1
     2a0:       83 32           cpi     r24, 0x23       ; 35
     2a2:       39 f4           brne    .+14            ; 0x2b2 <process_rxdata+0xfc>
     2a4:       80 91 e2 03     lds     r24, 0x03E2
     2a8:       88 23           and     r24, r24
     2aa:       19 f4           brne    .+6             ; 0x2b2 <process_rxdata+0xfc>
     2ac:       81 e0           ldi     r24, 0x01       ; 1
     2ae:       80 93 e5 03     sts     0x03E5, r24
                  buf_ptr = 0;
                  RxdBuffer[buf_ptr++] = SioTmp;
     2b2:       80 91 e1 03     lds     r24, 0x03E1
     2b6:       80 93 f4 03     sts     0x03F4, r24
     2ba:       81 e0           ldi     r24, 0x01       ; 1
     2bc:       80 93 e6 03     sts     0x03E6, r24
                  crc = SioTmp;
     2c0:       80 91 e1 03     lds     r24, 0x03E1
     2c4:       99 27           eor     r25, r25
     2c6:       90 93 ea 03     sts     0x03EA, r25
     2ca:       80 93 e9 03     sts     0x03E9, r24
                  display_line1[2]='A';
     2ce:       81 e4           ldi     r24, 0x41       ; 65
     2d0:       80 93 5a 04     sts     0x045A, r24
                  display_line1[1]='X';
     2d4:       88 e5           ldi     r24, 0x58       ; 88
     2d6:       80 93 59 04     sts     0x0459, r24
     2da:       43 c0           rjmp    .+134           ; 0x362 <process_rxdata+0x1ac>
          break;
                case 1: // Adresse auswerten
                  UartState++;
     2dc:       82 e0           ldi     r24, 0x02       ; 2
     2de:       80 93 e5 03     sts     0x03E5, r24
                  RxdBuffer[buf_ptr++] = SioTmp;
     2e2:       80 91 e1 03     lds     r24, 0x03E1
     2e6:       e4 ef           ldi     r30, 0xF4       ; 244
     2e8:       f3 e0           ldi     r31, 0x03       ; 3
     2ea:       e5 0f           add     r30, r21
     2ec:       f1 1d           adc     r31, r1
     2ee:       80 83           st      Z, r24
     2f0:       85 2f           mov     r24, r21
     2f2:       8f 5f           subi    r24, 0xFF       ; 255
     2f4:       80 93 e6 03     sts     0x03E6, r24
                  crc += SioTmp;
     2f8:       20 91 e1 03     lds     r18, 0x03E1
     2fc:       80 91 e9 03     lds     r24, 0x03E9
     300:       90 91 ea 03     lds     r25, 0x03EA
     304:       82 0f           add     r24, r18
     306:       91 1d           adc     r25, r1
     308:       90 93 ea 03     sts     0x03EA, r25
     30c:       80 93 e9 03     sts     0x03E9, r24
                  display_line1[2]='B';
     310:       82 e4           ldi     r24, 0x42       ; 66
     312:       80 93 5a 04     sts     0x045A, r24
     316:       25 c0           rjmp    .+74            ; 0x362 <process_rxdata+0x1ac>
                  break;
                case 2: //  Eingangsdaten sammeln
                  RxdBuffer[buf_ptr] = SioTmp;
     318:       80 91 e1 03     lds     r24, 0x03E1
     31c:       e4 ef           ldi     r30, 0xF4       ; 244
     31e:       f3 e0           ldi     r31, 0x03       ; 3
     320:       e5 0f           add     r30, r21
     322:       f1 1d           adc     r31, r1
     324:       80 83           st      Z, r24
                  if(buf_ptr < MAX_RX_BUF) buf_ptr++; 
     326:       54 36           cpi     r21, 0x64       ; 100
     328:       28 f4           brcc    .+10            ; 0x334 <process_rxdata+0x17e>
     32a:       85 2f           mov     r24, r21
     32c:       8f 5f           subi    r24, 0xFF       ; 255
     32e:       80 93 e6 03     sts     0x03E6, r24
     332:       02 c0           rjmp    .+4             ; 0x338 <process_rxdata+0x182>
                  else UartState = 0;
     334:       10 92 e5 03     sts     0x03E5, r1
                  crc += SioTmp;
     338:       80 91 e1 03     lds     r24, 0x03E1
     33c:       20 91 e9 03     lds     r18, 0x03E9
     340:       30 91 ea 03     lds     r19, 0x03EA
     344:       28 0f           add     r18, r24
     346:       31 1d           adc     r19, r1
     348:       30 93 ea 03     sts     0x03EA, r19
     34c:       20 93 e9 03     sts     0x03E9, r18
                  display_line1[2]='C';
     350:       83 e4           ldi     r24, 0x43       ; 67
     352:       80 93 5a 04     sts     0x045A, r24
     356:       05 c0           rjmp    .+10            ; 0x362 <process_rxdata+0x1ac>
                  break;
                default: 
          UartState = 0; 
     358:       10 92 e5 03     sts     0x03E5, r1
                  display_line1[2]='D';
     35c:       84 e4           ldi     r24, 0x44       ; 68
     35e:       80 93 5a 04     sts     0x045A, r24
          break;
        }       
        
        
        if(rxtx[8]==0x00) 
     362:       80 91 0a 01     lds     r24, 0x010A
     366:       88 23           and     r24, r24
     368:       21 f4           brne    .+8             ; 0x372 <process_rxdata+0x1bc>
                rxtx[8]=0x01;
     36a:       81 e0           ldi     r24, 0x01       ; 1
     36c:       80 93 0a 01     sts     0x010A, r24
     370:       08 95           ret
        else
                rxtx[8]=0x00;
     372:       10 92 0a 01     sts     0x010A, r1
     376:       08 95           ret

00000378 <convert_uint16>:
}

//-----------------------------------------------------------------------------
// convert_uint16 
//-----------------------------------------------------------------------------
extern void convert_uint16(unsigned char * c,int len, unsigned int value)
{
     378:       af 92           push    r10
     37a:       bf 92           push    r11
     37c:       cf 92           push    r12
     37e:       df 92           push    r13
     380:       ef 92           push    r14
     382:       ff 92           push    r15
     384:       0f 93           push    r16
     386:       1f 93           push    r17
     388:       cf 93           push    r28
     38a:       df 93           push    r29
     38c:       cd b7           in      r28, 0x3d       ; 61
     38e:       de b7           in      r29, 0x3e       ; 62
     390:       27 97           sbiw    r28, 0x07       ; 7
     392:       0f b6           in      r0, 0x3f        ; 63
     394:       f8 94           cli
     396:       de bf           out     0x3e, r29       ; 62
     398:       0f be           out     0x3f, r0        ; 63
     39a:       cd bf           out     0x3d, r28       ; 61
     39c:       6c 01           movw    r12, r24
     39e:       7b 01           movw    r14, r22
   int tempvalue, i; 
   char c1[7];
   
   if(len<1) return;
     3a0:       16 16           cp      r1, r22
     3a2:       17 06           cpc     r1, r23
     3a4:       0c f0           brlt    .+2             ; 0x3a8 <convert_uint16+0x30>
     3a6:       45 c0           rjmp    .+138           ; 0x432 <convert_uint16+0xba>
     3a8:       80 e0           ldi     r24, 0x00       ; 0
     3aa:       90 e0           ldi     r25, 0x00       ; 0
     3ac:       9e 01           movw    r18, r28
     3ae:       2f 5f           subi    r18, 0xFF       ; 255
     3b0:       3f 4f           sbci    r19, 0xFF       ; 255
     3b2:       60 e3           ldi     r22, 0x30       ; 48
   for(i=0;i<len;i++) {
     c1[i]='0';
     3b4:       f9 01           movw    r30, r18
     3b6:       e8 0f           add     r30, r24
     3b8:       f9 1f           adc     r31, r25
     3ba:       60 83           st      Z, r22
     3bc:       01 96           adiw    r24, 0x01       ; 1
     3be:       e8 16           cp      r14, r24
     3c0:       f9 06           cpc     r15, r25
     3c2:       c1 f7           brne    .-16            ; 0x3b4 <convert_uint16+0x3c>
   }
     
   i=len-1; 
   while(value>0) {
     3c4:       41 15           cp      r20, r1
     3c6:       51 05           cpc     r21, r1
     3c8:       19 f1           breq    .+70            ; 0x410 <convert_uint16+0x98>
     3ca:       87 01           movw    r16, r14
     3cc:       01 50           subi    r16, 0x01       ; 1
     3ce:       10 40           sbci    r17, 0x00       ; 0
     3d0:       5e 01           movw    r10, r28
     3d2:       08 94           sec
     3d4:       a1 1c           adc     r10, r1
     3d6:       b1 1c           adc     r11, r1
     tempvalue=value;
     3d8:       fa 01           movw    r30, r20
         value=value/10;
     3da:       ca 01           movw    r24, r20
     3dc:       6a e0           ldi     r22, 0x0A       ; 10
     3de:       70 e0           ldi     r23, 0x00       ; 0
     3e0:       c3 d6           rcall   .+3462          ; 0x1168 <__udivmodhi4>
     3e2:       ab 01           movw    r20, r22
         c1[i]=(tempvalue-(value*10))+'0'; 
     3e4:       d5 01           movw    r26, r10
     3e6:       a0 0f           add     r26, r16
     3e8:       b1 1f           adc     r27, r17
     3ea:       cb 01           movw    r24, r22
     3ec:       88 0f           add     r24, r24
     3ee:       99 1f           adc     r25, r25
     3f0:       9b 01           movw    r18, r22
     3f2:       22 0f           add     r18, r18
     3f4:       33 1f           adc     r19, r19
     3f6:       22 0f           add     r18, r18
     3f8:       33 1f           adc     r19, r19
     3fa:       22 0f           add     r18, r18
     3fc:       33 1f           adc     r19, r19
     3fe:       82 0f           add     r24, r18
     400:       93 1f           adc     r25, r19
     402:       e8 1b           sub     r30, r24
     404:       e0 5d           subi    r30, 0xD0       ; 208
     406:       ec 93           st      X, r30
         i--;
     408:       01 50           subi    r16, 0x01       ; 1
     40a:       10 40           sbci    r17, 0x00       ; 0
     40c:       67 2b           or      r22, r23
     40e:       21 f7           brne    .-56            ; 0x3d8 <convert_uint16+0x60>
     410:       20 e0           ldi     r18, 0x00       ; 0
     412:       30 e0           ldi     r19, 0x00       ; 0
     414:       ae 01           movw    r20, r28
     416:       4f 5f           subi    r20, 0xFF       ; 255
     418:       5f 4f           sbci    r21, 0xFF       ; 255
   }
   for(i=0;i<len;i++) {
     *c=c1[i]; 
     41a:       fa 01           movw    r30, r20
     41c:       e2 0f           add     r30, r18
     41e:       f3 1f           adc     r31, r19
     420:       80 81           ld      r24, Z
     422:       f6 01           movw    r30, r12
     424:       81 93           st      Z+, r24
     426:       6f 01           movw    r12, r30
     428:       2f 5f           subi    r18, 0xFF       ; 255
     42a:       3f 4f           sbci    r19, 0xFF       ; 255
     42c:       e2 16           cp      r14, r18
     42e:       f3 06           cpc     r15, r19
     430:       a1 f7           brne    .-24            ; 0x41a <convert_uint16+0xa2>
     432:       27 96           adiw    r28, 0x07       ; 7
     434:       0f b6           in      r0, 0x3f        ; 63
     436:       f8 94           cli
     438:       de bf           out     0x3e, r29       ; 62
     43a:       0f be           out     0x3f, r0        ; 63
     43c:       cd bf           out     0x3d, r28       ; 61
     43e:       df 91           pop     r29
     440:       cf 91           pop     r28
     442:       1f 91           pop     r17
     444:       0f 91           pop     r16
     446:       ff 90           pop     r15
     448:       ef 90           pop     r14
     44a:       df 90           pop     r13
     44c:       cf 90           pop     r12
     44e:       bf 90           pop     r11
     450:       af 90           pop     r10
     452:       08 95           ret

00000454 <main>:
         c++;

   }
}


//-----------------------------------------------------------------------------
//main 
//main execution loop
//-----------------------------------------------------------------------------
extern int main(void)
{
     454:       af 92           push    r10
     456:       bf 92           push    r11
     458:       cf 92           push    r12
     45a:       df 92           push    r13
     45c:       ff 92           push    r15
     45e:       0f 93           push    r16
     460:       1f 93           push    r17
     462:       cf 93           push    r28
     464:       df 93           push    r29
        unsigned char c;
        unsigned int i; 
        int i1; 
        
        HIDEGRAPHIC;
     466:       10 92 00 01     sts     0x0100, r1
        HIDEGRAPHICBACK; 
     46a:       10 92 01 01     sts     0x0101, r1
        
        CLKPR=0x80;
     46e:       e1 e6           ldi     r30, 0x61       ; 97
     470:       f0 e0           ldi     r31, 0x00       ; 0
     472:       80 e8           ldi     r24, 0x80       ; 128
     474:       80 83           st      Z, r24
        CLKPR=0x00;
     476:       10 82           st      Z, r1

        // PORT D - unused right now    
        PORTD = 0x10;                                                   
     478:       80 e1           ldi     r24, 0x10       ; 16
     47a:       8b b9           out     0x0b, r24       ; 11
        DDRD  = 0x00;                                                   
     47c:       1a b8           out     0x0a, r1        ; 10

        // USART initialization
        // Communication Parameters: 8 Data, 1 Stop, No Parity
        // USART Receiver: On
        // USART Transmitter: On
        // USART Mode: Asynchronous
        // USART Baud rate: 57600       
        UCSR0A=0x00;
     47e:       10 92 c0 00     sts     0x00C0, r1
        UCSR0B=0x18;
     482:       88 e1           ldi     r24, 0x18       ; 24
     484:       80 93 c1 00     sts     0x00C1, r24
        UCSR0C=0x86;
     488:       86 e8           ldi     r24, 0x86       ; 134
     48a:       80 93 c2 00     sts     0x00C2, r24
#ifdef CPUSPEED_20      //20.000MHz
        UBRR0H=0x00;
     48e:       10 92 c5 00     sts     0x00C5, r1
        UBRR0L=0x15;    
     492:       85 e1           ldi     r24, 0x15       ; 21
     494:       80 93 c4 00     sts     0x00C4, r24
#endif

#ifdef CPUSPEED_16      //16.000MHz
        UBRR0H=0x00;
        UBRR0L=0x10;
#endif
        
#ifdef CPUSPEED_11059 //11.059MHz
        UBRR0H=0x00;
        UBRR0L=0x0B;
#endif

        // Initialize the 8-bit Timer0 to clock at 20/8 MHz */
        TCCR0A=0x00;
     498:       14 bc           out     0x24, r1        ; 36
        TCCR0B=0x01;
     49a:       91 e0           ldi     r25, 0x01       ; 1
     49c:       95 bd           out     0x25, r25       ; 37

        // Initialize the SPI Interface
        PORTB = 0x00;
     49e:       15 b8           out     0x05, r1        ; 5
        DDRB = 0x3E; //0x3E
     4a0:       8e e3           ldi     r24, 0x3E       ; 62
     4a2:       84 b9           out     0x04, r24       ; 4
        //DDRB = 0x3A; 
                                        
        SPCR = (1<<SPE) | (1<<MSTR) | (1<<CPHA);
     4a4:       84 e5           ldi     r24, 0x54       ; 84
     4a6:       8c bd           out     0x2c, r24       ; 44
        SPSR = 1;
     4a8:       9d bd           out     0x2d, r25       ; 45

        // External Interrupt(s) initialization
        // INT0: On
        // INT0 Mode: Falling Edge
        // INT1: On
        // INT1 Mode: Falling Edge
        // Interrupt on any change on pins PCINT0-7: Off
        // Interrupt on any change on pins PCINT8-14: Off
        // Interrupt on any change on pins PCINT16-23: Off
        EICRA=0x0A;
     4aa:       8a e0           ldi     r24, 0x0A       ; 10
     4ac:       80 93 69 00     sts     0x0069, r24
        EIMSK=0x03;
     4b0:       83 e0           ldi     r24, 0x03       ; 3
     4b2:       8d bb           out     0x1d, r24       ; 29
        EIFR=0x03;
     4b4:       8c bb           out     0x1c, r24       ; 28
        PCICR=0x00;
     4b6:       10 92 68 00     sts     0x0068, r1

        // Enable interrupts
        sei();
     4ba:       78 94           sei

        // MAIN lOOP
        display_line1[0]='X';
     4bc:       88 e5           ldi     r24, 0x58       ; 88
     4be:       80 93 58 04     sts     0x0458, r24
        display_line1[1]='X';
     4c2:       80 93 59 04     sts     0x0459, r24
        display_line1[2]='X';
     4c6:       80 93 5a 04     sts     0x045A, r24
        display_line1[3]='X';
     4ca:       80 93 5b 04     sts     0x045B, r24
        display_line1[4]='X';
     4ce:       80 93 5c 04     sts     0x045C, r24
        display_line1[5]='X';
     4d2:       80 93 5d 04     sts     0x045D, r24
        
        NeuerDatensatzEmpfangen = 0; 
     4d6:       10 92 e2 03     sts     0x03E2, r1
        
        framecounter = 0; 
     4da:       10 92 da 03     sts     0x03DA, r1
        
        GR_Clear();
     4de:       d7 dd           rcall   .-1106          ; 0x8e <GR_Clear>
        GR_Copy(&grlevel[0],(GR_Lines/2)*7,21);
     4e0:       45 e1           ldi     r20, 0x15       ; 21
     4e2:       50 e0           ldi     r21, 0x00       ; 0
     4e4:       6c e8           ldi     r22, 0x8C       ; 140
     4e6:       70 e0           ldi     r23, 0x00       ; 0
     4e8:       8b eb           ldi     r24, 0xBB       ; 187
     4ea:       93 e0           ldi     r25, 0x03       ; 3
     4ec:       bf dd           rcall   .-1154          ; 0x6c <GR_Copy>
        SHOWGRAPHIC;
     4ee:       81 e0           ldi     r24, 0x01       ; 1
     4f0:       80 93 00 01     sts     0x0100, r24
     4f4:       ff 24           eor     r15, r15
     4f6:       f3 94           inc     r15
     4f8:       0f 2e           mov     r0, r31
     4fa:       ff ee           ldi     r31, 0xEF       ; 239
     4fc:       cf 2e           mov     r12, r31
     4fe:       f3 e0           ldi     r31, 0x03       ; 3
     500:       df 2e           mov     r13, r31
     502:       f0 2d           mov     r31, r0
     504:       08 e0           ldi     r16, 0x08       ; 8
     506:       14 e0           ldi     r17, 0x04       ; 4
     508:       0f 2e           mov     r0, r31
     50a:       fb eb           ldi     r31, 0xBB       ; 187
     50c:       af 2e           mov     r10, r31
     50e:       f3 e0           ldi     r31, 0x03       ; 3
     510:       bf 2e           mov     r11, r31
     512:       f0 2d           mov     r31, r0
        
        while (1)
        {
                
                if (UCSR0A & (1<<RXC0)) {
     514:       80 91 c0 00     lds     r24, 0x00C0
     518:       88 23           and     r24, r24
     51a:       2c f4           brge    .+10            ; 0x526 <__stack+0x27>
                        c=UDR0;
     51c:       e6 ec           ldi     r30, 0xC6       ; 198
     51e:       f0 e0           ldi     r31, 0x00       ; 0
     520:       80 81           ld      r24, Z
                        UDR0=c;
     522:       80 83           st      Z, r24
                        process_rxdata(c);
     524:       48 de           rcall   .-880           ; 0x1b6 <process_rxdata>
                }
                
                if (framecounter<25) showmessage1=1; else showmessage1=0;
     526:       80 91 da 03     lds     r24, 0x03DA
     52a:       89 31           cpi     r24, 0x19       ; 25
     52c:       18 f4           brcc    .+6             ; 0x534 <__stack+0x35>
     52e:       f0 92 d9 03     sts     0x03D9, r15
     532:       06 c0           rjmp    .+12            ; 0x540 <__stack+0x41>
     534:       10 92 d9 03     sts     0x03D9, r1
                if (framecounter>50) framecounter = 0;  
     538:       83 33           cpi     r24, 0x33       ; 51
     53a:       10 f0           brcs    .+4             ; 0x540 <__stack+0x41>
     53c:       10 92 da 03     sts     0x03DA, r1
                
                if(NeuerDatensatzEmpfangen) {
     540:       80 91 e2 03     lds     r24, 0x03E2
     544:       88 23           and     r24, r24
     546:       31 f3           breq    .-52            ; 0x514 <__stack+0x15>
                        switch(RxdBuffer[2])
     548:       80 91 f6 03     lds     r24, 0x03F6
     54c:       84 34           cpi     r24, 0x44       ; 68
     54e:       09 f0           breq    .+2             ; 0x552 <__stack+0x53>
     550:       5f c1           rjmp    .+702           ; 0x810 <__stack+0x311>
                        {
                                case 'D':
                                        //decode the Messagee   
                                        Decode64((unsigned char *)&DebugOut,sizeof(DebugOut),3,AnzahlEmpfangsBytes);
     552:       20 91 e4 03     lds     r18, 0x03E4
     556:       43 e0           ldi     r20, 0x03       ; 3
     558:       62 e4           ldi     r22, 0x42       ; 66
     55a:       82 e6           ldi     r24, 0x62       ; 98
     55c:       94 e0           ldi     r25, 0x04       ; 4
     55e:       a0 dd           rcall   .-1216          ; 0xa0 <Decode64>
                                        
                                        // Heading information
                                        convert_uint16((unsigned char *)&heading[1],3,(unsigned int)DebugOut.Analog[8]);
     560:       40 91 74 04     lds     r20, 0x0474
     564:       50 91 75 04     lds     r21, 0x0475
     568:       63 e0           ldi     r22, 0x03       ; 3
     56a:       70 e0           ldi     r23, 0x00       ; 0
     56c:       8c e0           ldi     r24, 0x0C       ; 12
     56e:       91 e0           ldi     r25, 0x01       ; 1
     570:       03 df           rcall   .-506           ; 0x378 <convert_uint16>
                                        
                                        // Altitute Information 
                                        if(DebugOut.Analog[5]>old_alt) {
     572:       20 91 6e 04     lds     r18, 0x046E
     576:       30 91 6f 04     lds     r19, 0x046F
     57a:       80 91 eb 03     lds     r24, 0x03EB
     57e:       90 91 ec 03     lds     r25, 0x03EC
     582:       82 17           cp      r24, r18
     584:       93 07           cpc     r25, r19
     586:       64 f4           brge    .+24            ; 0x5a0 <__stack+0xa1>
                                          alt_inc=1;
     588:       f0 92 de 03     sts     0x03DE, r15
                                          alt_dec=0; 
     58c:       10 92 df 03     sts     0x03DF, r1
                                          alt_delta=DebugOut.Analog[5]-old_alt; 
     590:       a9 01           movw    r20, r18
     592:       48 1b           sub     r20, r24
     594:       59 0b           sbc     r21, r25
     596:       50 93 dd 03     sts     0x03DD, r21
     59a:       40 93 dc 03     sts     0x03DC, r20
     59e:       17 c0           rjmp    .+46            ; 0x5ce <__stack+0xcf>
                                        }
                                        else {
                                          if(DebugOut.Analog[5]<old_alt) { 
     5a0:       28 17           cp      r18, r24
     5a2:       39 07           cpc     r19, r25
     5a4:       5c f4           brge    .+22            ; 0x5bc <__stack+0xbd>
                                                alt_inc=0;
     5a6:       10 92 de 03     sts     0x03DE, r1
                                                alt_dec=1;
     5aa:       f0 92 df 03     sts     0x03DF, r15
                                                alt_delta=old_alt-DebugOut.Analog[5];
     5ae:       82 1b           sub     r24, r18
     5b0:       93 0b           sbc     r25, r19
     5b2:       90 93 dd 03     sts     0x03DD, r25
     5b6:       80 93 dc 03     sts     0x03DC, r24
     5ba:       09 c0           rjmp    .+18            ; 0x5ce <__stack+0xcf>
                                          }
                                          else {
                                                alt_inc=0;
     5bc:       10 92 de 03     sts     0x03DE, r1
                                                alt_dec=0;
     5c0:       10 92 df 03     sts     0x03DF, r1
                                                alt_delta=0;
     5c4:       10 92 dd 03     sts     0x03DD, r1
     5c8:       10 92 dc 03     sts     0x03DC, r1
     5cc:       0c c0           rjmp    .+24            ; 0x5e6 <__stack+0xe7>
                                          }
                                        } 
                                        if(alt_delta>60) alt_delta=60;
     5ce:       80 91 dc 03     lds     r24, 0x03DC
     5d2:       90 91 dd 03     lds     r25, 0x03DD
     5d6:       cd 97           sbiw    r24, 0x3d       ; 61
     5d8:       30 f0           brcs    .+12            ; 0x5e6 <__stack+0xe7>
     5da:       8c e3           ldi     r24, 0x3C       ; 60
     5dc:       90 e0           ldi     r25, 0x00       ; 0
     5de:       90 93 dd 03     sts     0x03DD, r25
     5e2:       80 93 dc 03     sts     0x03DC, r24
                                        if(alt_delta<0) alt_delta=0; 
                                        
                                        old_alt=DebugOut.Analog[5]; 
     5e6:       30 93 ec 03     sts     0x03EC, r19
     5ea:       20 93 eb 03     sts     0x03EB, r18
                                        if(DebugOut.Analog[5]<0) {
     5ee:       33 23           and     r19, r19
     5f0:       5c f4           brge    .+22            ; 0x608 <__stack+0x109>
                                          altv[0]='-';
     5f2:       8d e2           ldi     r24, 0x2D       ; 45
     5f4:       80 93 30 01     sts     0x0130, r24
                                          DebugOut.Analog[5]=(0xffff-(unsigned int)DebugOut.Analog[5]);
     5f8:       c9 01           movw    r24, r18
     5fa:       80 95           com     r24
     5fc:       90 95           com     r25
     5fe:       90 93 6f 04     sts     0x046F, r25
     602:       80 93 6e 04     sts     0x046E, r24
     606:       03 c0           rjmp    .+6             ; 0x60e <__stack+0x10f>
                                        }
                                        else {
                                          altv[0]='+'; 
     608:       8b e2           ldi     r24, 0x2B       ; 43
     60a:       80 93 30 01     sts     0x0130, r24
                                        }
                                        convert_uint16((unsigned char *)&altv[1],5,(unsigned int)DebugOut.Analog[5]);
     60e:       40 91 6e 04     lds     r20, 0x046E
     612:       50 91 6f 04     lds     r21, 0x046F
     616:       65 e0           ldi     r22, 0x05       ; 5
     618:       70 e0           ldi     r23, 0x00       ; 0
     61a:       81 e3           ldi     r24, 0x31       ; 49
     61c:       91 e0           ldi     r25, 0x01       ; 1
     61e:       ac de           rcall   .-680           ; 0x378 <convert_uint16>
                                        
                                        //Voltage value
                                        convert_uint16((unsigned char *)&templine[0],5,(unsigned int)DebugOut.Analog[9]);
     620:       40 91 76 04     lds     r20, 0x0476
     624:       50 91 77 04     lds     r21, 0x0477
     628:       65 e0           ldi     r22, 0x05       ; 5
     62a:       70 e0           ldi     r23, 0x00       ; 0
     62c:       c6 01           movw    r24, r12
     62e:       a4 de           rcall   .-696           ; 0x378 <convert_uint16>
                                        ubat[3]=templine[2];
     630:       80 91 f1 03     lds     r24, 0x03F1
     634:       80 93 1b 01     sts     0x011B, r24
                                        ubat[4]=templine[3];
     638:       80 91 f2 03     lds     r24, 0x03F2
     63c:       80 93 1c 01     sts     0x011C, r24
                                        ubat[6]=templine[4];
     640:       80 91 f3 03     lds     r24, 0x03F3
     644:       80 93 1e 01     sts     0x011E, r24
                                        
                                        if(DebugOut.Analog[9]>90) bat[0]=0x08; else bat[0]=0x04; 
     648:       80 91 76 04     lds     r24, 0x0476
     64c:       90 91 77 04     lds     r25, 0x0477
     650:       8b 35           cpi     r24, 0x5B       ; 91
     652:       91 05           cpc     r25, r1
     654:       34 f0           brlt    .+12            ; 0x662 <__stack+0x163>
     656:       00 93 10 01     sts     0x0110, r16
                                        if(DebugOut.Analog[9]>95) bat[1]=0x08; else bat[1]=0x04;
     65a:       80 36           cpi     r24, 0x60       ; 96
     65c:       91 05           cpc     r25, r1
     65e:       24 f4           brge    .+8             ; 0x668 <__stack+0x169>
     660:       09 c0           rjmp    .+18            ; 0x674 <__stack+0x175>
     662:       10 93 10 01     sts     0x0110, r17
     666:       06 c0           rjmp    .+12            ; 0x674 <__stack+0x175>
     668:       00 93 11 01     sts     0x0111, r16
                                        if(DebugOut.Analog[9]>100) bat[2]=0x08; else bat[2]=0x04;
     66c:       85 36           cpi     r24, 0x65       ; 101
     66e:       91 05           cpc     r25, r1
     670:       24 f4           brge    .+8             ; 0x67a <__stack+0x17b>
     672:       09 c0           rjmp    .+18            ; 0x686 <__stack+0x187>
     674:       10 93 11 01     sts     0x0111, r17
     678:       06 c0           rjmp    .+12            ; 0x686 <__stack+0x187>
     67a:       00 93 12 01     sts     0x0112, r16
                                        if(DebugOut.Analog[9]>105) bat[3]=0x08; else bat[3]=0x04;
     67e:       8a 36           cpi     r24, 0x6A       ; 106
     680:       91 05           cpc     r25, r1
     682:       24 f4           brge    .+8             ; 0x68c <__stack+0x18d>
     684:       09 c0           rjmp    .+18            ; 0x698 <__stack+0x199>
     686:       10 93 12 01     sts     0x0112, r17
     68a:       06 c0           rjmp    .+12            ; 0x698 <__stack+0x199>
     68c:       00 93 13 01     sts     0x0113, r16
                                        if(DebugOut.Analog[9]>110) bat[4]=0x08; else bat[4]=0x04;
     690:       8f 36           cpi     r24, 0x6F       ; 111
     692:       91 05           cpc     r25, r1
     694:       24 f4           brge    .+8             ; 0x69e <__stack+0x19f>
     696:       09 c0           rjmp    .+18            ; 0x6aa <__stack+0x1ab>
     698:       10 93 13 01     sts     0x0113, r17
     69c:       06 c0           rjmp    .+12            ; 0x6aa <__stack+0x1ab>
     69e:       00 93 14 01     sts     0x0114, r16
                                        if(DebugOut.Analog[9]>115) bat[5]=0x08; else bat[5]=0x04;
     6a2:       84 37           cpi     r24, 0x74       ; 116
     6a4:       91 05           cpc     r25, r1
     6a6:       24 f4           brge    .+8             ; 0x6b0 <__stack+0x1b1>
     6a8:       09 c0           rjmp    .+18            ; 0x6bc <__stack+0x1bd>
     6aa:       10 93 14 01     sts     0x0114, r17
     6ae:       06 c0           rjmp    .+12            ; 0x6bc <__stack+0x1bd>
     6b0:       00 93 15 01     sts     0x0115, r16
                                        if(DebugOut.Analog[9]>120) bat[6]=0x08; else bat[6]=0x04;
     6b4:       89 37           cpi     r24, 0x79       ; 121
     6b6:       91 05           cpc     r25, r1
     6b8:       24 f4           brge    .+8             ; 0x6c2 <__stack+0x1c3>
     6ba:       09 c0           rjmp    .+18            ; 0x6ce <__stack+0x1cf>
     6bc:       10 93 15 01     sts     0x0115, r17
     6c0:       06 c0           rjmp    .+12            ; 0x6ce <__stack+0x1cf>
     6c2:       00 93 16 01     sts     0x0116, r16
                                        if(DebugOut.Analog[9]>125) bat[7]=0x08; else bat[7]=0x04;
     6c6:       8e 37           cpi     r24, 0x7E       ; 126
     6c8:       91 05           cpc     r25, r1
     6ca:       4c f4           brge    .+18            ; 0x6de <__stack+0x1df>
     6cc:       b4 c0           rjmp    .+360           ; 0x836 <__stack+0x337>
     6ce:       10 93 16 01     sts     0x0116, r17
     6d2:       10 93 17 01     sts     0x0117, r17
                                        
                                        if(DebugOut.Analog[9]<94) lowbat=1; else lowbat = 0;
     6d6:       8e 35           cpi     r24, 0x5E       ; 94
     6d8:       91 05           cpc     r25, r1
     6da:       24 f0           brlt    .+8             ; 0x6e4 <__stack+0x1e5>
     6dc:       06 c0           rjmp    .+12            ; 0x6ea <__stack+0x1eb>
     6de:       00 93 17 01     sts     0x0117, r16
     6e2:       03 c0           rjmp    .+6             ; 0x6ea <__stack+0x1eb>
     6e4:       f0 92 d8 03     sts     0x03D8, r15
     6e8:       02 c0           rjmp    .+4             ; 0x6ee <__stack+0x1ef>
     6ea:       10 92 d8 03     sts     0x03D8, r1
                                        
                                        //RX level
                                        i=((unsigned int)DebugOut.Analog[10]*100)/255;
     6ee:       20 91 78 04     lds     r18, 0x0478
     6f2:       30 91 79 04     lds     r19, 0x0479
     6f6:       84 e6           ldi     r24, 0x64       ; 100
     6f8:       90 e0           ldi     r25, 0x00       ; 0
     6fa:       ac 01           movw    r20, r24
     6fc:       24 9f           mul     r18, r20
     6fe:       c0 01           movw    r24, r0
     700:       25 9f           mul     r18, r21
     702:       90 0d           add     r25, r0
     704:       34 9f           mul     r19, r20
     706:       90 0d           add     r25, r0
     708:       11 24           eor     r1, r1
     70a:       6f ef           ldi     r22, 0xFF       ; 255
     70c:       70 e0           ldi     r23, 0x00       ; 0
     70e:       2c d5           rcall   .+2648          ; 0x1168 <__udivmodhi4>
     710:       eb 01           movw    r28, r22
                                        
                                        convert_uint16((unsigned char *)&templine[0],5,(unsigned int)i);
     712:       ab 01           movw    r20, r22
     714:       65 e0           ldi     r22, 0x05       ; 5
     716:       70 e0           ldi     r23, 0x00       ; 0
     718:       c6 01           movw    r24, r12
     71a:       2e de           rcall   .-932           ; 0x378 <convert_uint16>
                                        urx[4]=templine[2];
     71c:       80 91 f1 03     lds     r24, 0x03F1
     720:       80 93 2c 01     sts     0x012C, r24
                                        urx[5]=templine[3];
     724:       80 91 f2 03     lds     r24, 0x03F2
     728:       80 93 2d 01     sts     0x012D, r24
                                        urx[6]=templine[4];
     72c:       80 91 f3 03     lds     r24, 0x03F3
     730:       80 93 2e 01     sts     0x012E, r24
                                        
                                        if(i>10) rx[0]=0x08; else rx[0]=0x04;
     734:       cb 30           cpi     r28, 0x0B       ; 11
     736:       d1 05           cpc     r29, r1
     738:       30 f0           brcs    .+12            ; 0x746 <__stack+0x247>
     73a:       00 93 20 01     sts     0x0120, r16
                                        if(i>20) rx[1]=0x08; else rx[1]=0x04;
     73e:       c5 31           cpi     r28, 0x15       ; 21
     740:       d1 05           cpc     r29, r1
     742:       20 f4           brcc    .+8             ; 0x74c <__stack+0x24d>
     744:       09 c0           rjmp    .+18            ; 0x758 <__stack+0x259>
     746:       10 93 20 01     sts     0x0120, r17
     74a:       06 c0           rjmp    .+12            ; 0x758 <__stack+0x259>
     74c:       00 93 21 01     sts     0x0121, r16
                                        if(i>30) rx[2]=0x08; else rx[2]=0x04;
     750:       cf 31           cpi     r28, 0x1F       ; 31
     752:       d1 05           cpc     r29, r1
     754:       20 f4           brcc    .+8             ; 0x75e <__stack+0x25f>
     756:       09 c0           rjmp    .+18            ; 0x76a <__stack+0x26b>
     758:       10 93 21 01     sts     0x0121, r17
     75c:       06 c0           rjmp    .+12            ; 0x76a <__stack+0x26b>
     75e:       00 93 22 01     sts     0x0122, r16
                                        if(i>40) rx[3]=0x08; else rx[3]=0x04;
     762:       c9 32           cpi     r28, 0x29       ; 41
     764:       d1 05           cpc     r29, r1
     766:       20 f4           brcc    .+8             ; 0x770 <__stack+0x271>
     768:       09 c0           rjmp    .+18            ; 0x77c <__stack+0x27d>
     76a:       10 93 22 01     sts     0x0122, r17
     76e:       06 c0           rjmp    .+12            ; 0x77c <__stack+0x27d>
     770:       00 93 23 01     sts     0x0123, r16
                                        if(i>50) rx[4]=0x08; else rx[4]=0x04;
     774:       c3 33           cpi     r28, 0x33       ; 51
     776:       d1 05           cpc     r29, r1
     778:       20 f4           brcc    .+8             ; 0x782 <__stack+0x283>
     77a:       09 c0           rjmp    .+18            ; 0x78e <__stack+0x28f>
     77c:       10 93 23 01     sts     0x0123, r17
     780:       06 c0           rjmp    .+12            ; 0x78e <__stack+0x28f>
     782:       00 93 24 01     sts     0x0124, r16
                                        if(i>60) rx[5]=0x08; else rx[5]=0x04;
     786:       cd 33           cpi     r28, 0x3D       ; 61
     788:       d1 05           cpc     r29, r1
     78a:       20 f4           brcc    .+8             ; 0x794 <__stack+0x295>
     78c:       09 c0           rjmp    .+18            ; 0x7a0 <__stack+0x2a1>
     78e:       10 93 24 01     sts     0x0124, r17
     792:       06 c0           rjmp    .+12            ; 0x7a0 <__stack+0x2a1>
     794:       00 93 25 01     sts     0x0125, r16
                                        if(i>70) rx[6]=0x08; else rx[6]=0x04;
     798:       c7 34           cpi     r28, 0x47       ; 71
     79a:       d1 05           cpc     r29, r1
     79c:       20 f4           brcc    .+8             ; 0x7a6 <__stack+0x2a7>
     79e:       09 c0           rjmp    .+18            ; 0x7b2 <__stack+0x2b3>
     7a0:       10 93 25 01     sts     0x0125, r17
     7a4:       06 c0           rjmp    .+12            ; 0x7b2 <__stack+0x2b3>
     7a6:       00 93 26 01     sts     0x0126, r16
                                        if(i>80) rx[7]=0x08; else rx[7]=0x04;
     7aa:       c1 35           cpi     r28, 0x51       ; 81
     7ac:       d1 05           cpc     r29, r1
     7ae:       20 f4           brcc    .+8             ; 0x7b8 <__stack+0x2b9>
     7b0:       06 c0           rjmp    .+12            ; 0x7be <__stack+0x2bf>
     7b2:       10 93 26 01     sts     0x0126, r17
     7b6:       03 c0           rjmp    .+6             ; 0x7be <__stack+0x2bf>
     7b8:       00 93 27 01     sts     0x0127, r16
     7bc:       02 c0           rjmp    .+4             ; 0x7c2 <__stack+0x2c3>
     7be:       10 93 27 01     sts     0x0127, r17
                                        
                                        // nick
                                        i1=DebugOut.Analog[0]/50;
     7c2:       80 91 64 04     lds     r24, 0x0464
     7c6:       90 91 65 04     lds     r25, 0x0465
     7ca:       62 e3           ldi     r22, 0x32       ; 50
     7cc:       70 e0           ldi     r23, 0x00       ; 0
     7ce:       e0 d4           rcall   .+2496          ; 0x1190 <__divmodhi4>
                                        i1=((GR_Lines/2)-i1);
     7d0:       84 e1           ldi     r24, 0x14       ; 20
     7d2:       90 e0           ldi     r25, 0x00       ; 0
     7d4:       ec 01           movw    r28, r24
     7d6:       c6 1b           sub     r28, r22
     7d8:       d7 0b           sbc     r29, r23
                                        if(i1<0) i1=0;
     7da:       ea f0           brmi    .+58            ; 0x816 <__stack+0x317>
                                        if(i1>37) i1=37;
     7dc:       c6 32           cpi     r28, 0x26       ; 38
     7de:       d1 05           cpc     r29, r1
     7e0:       14 f5           brge    .+68            ; 0x826 <__stack+0x327>
                                        GR_Clear();
     7e2:       55 dc           rcall   .-1878          ; 0x8e <GR_Clear>
                                        GR_Copy(&grlevel[0],i1*7,21);
     7e4:       be 01           movw    r22, r28
     7e6:       66 0f           add     r22, r22
     7e8:       77 1f           adc     r23, r23
     7ea:       66 0f           add     r22, r22
     7ec:       77 1f           adc     r23, r23
     7ee:       66 0f           add     r22, r22
     7f0:       77 1f           adc     r23, r23
     7f2:       6c 1b           sub     r22, r28
     7f4:       7d 0b           sbc     r23, r29
     7f6:       45 e1           ldi     r20, 0x15       ; 21
     7f8:       50 e0           ldi     r21, 0x00       ; 0
     7fa:       c5 01           movw    r24, r10
     7fc:       37 dc           rcall   .-1938          ; 0x6c <GR_Copy>
                                        if(i1!=20) GR_Copy(&grlevel0[0],20*7,7);
     7fe:       64 97           sbiw    r28, 0x14       ; 20
     800:       39 f0           breq    .+14            ; 0x810 <__stack+0x311>
     802:       47 e0           ldi     r20, 0x07       ; 7
     804:       50 e0           ldi     r21, 0x00       ; 0
     806:       6c e8           ldi     r22, 0x8C       ; 140
     808:       70 e0           ldi     r23, 0x00       ; 0
     80a:       80 ed           ldi     r24, 0xD0       ; 208
     80c:       93 e0           ldi     r25, 0x03       ; 3
     80e:       2e dc           rcall   .-1956          ; 0x6c <GR_Copy>
                                        break;
                                        

                                        
                                default:
                                        break;
                                
                        }
                        NeuerDatensatzEmpfangen=0;
     810:       10 92 e2 03     sts     0x03E2, r1
     814:       7f ce           rjmp    .-770           ; 0x514 <__stack+0x15>
     816:       3b dc           rcall   .-1930          ; 0x8e <GR_Clear>
     818:       45 e1           ldi     r20, 0x15       ; 21
     81a:       50 e0           ldi     r21, 0x00       ; 0
     81c:       60 e0           ldi     r22, 0x00       ; 0
     81e:       70 e0           ldi     r23, 0x00       ; 0
     820:       c5 01           movw    r24, r10
     822:       24 dc           rcall   .-1976          ; 0x6c <GR_Copy>
     824:       ee cf           rjmp    .-36            ; 0x802 <__stack+0x303>
     826:       33 dc           rcall   .-1946          ; 0x8e <GR_Clear>
     828:       45 e1           ldi     r20, 0x15       ; 21
     82a:       50 e0           ldi     r21, 0x00       ; 0
     82c:       63 e0           ldi     r22, 0x03       ; 3
     82e:       71 e0           ldi     r23, 0x01       ; 1
     830:       c5 01           movw    r24, r10
     832:       1c dc           rcall   .-1992          ; 0x6c <GR_Copy>
     834:       e6 cf           rjmp    .-52            ; 0x802 <__stack+0x303>
     836:       10 93 17 01     sts     0x0117, r17
     83a:       57 cf           rjmp    .-338           ; 0x6ea <__stack+0x1eb>

0000083c <draw_line>:
                }
        }
        return(1);
}       /* main */



//-----------------------------------------------------------------------------
// draw line() 
// will be executed in interrupt context and will display the overlay content
//-----------------------------------------------------------------------------*/
extern void draw_line()
{
     83c:       40 91 ed 03     lds     r20, 0x03ED
     840:       50 91 ee 03     lds     r21, 0x03EE
     844:       ca 01           movw    r24, r20
     846:       84 97           sbiw    r24, 0x24       ; 36
     848:       07 97           sbiw    r24, 0x07       ; 7
     84a:       08 f0           brcs    .+2             ; 0x84e <draw_line+0x12>
     84c:       03 c1           rjmp    .+518           ; 0xa54 <draw_line+0x218>
        unsigned char *ltr_p;
        unsigned char *num_p;
        unsigned char *info_p;
        short ltemp;    
        short ntemp;
        short itemp;
        unsigned int i1; 
        unsigned char i=0; 
        unsigned char c1; 
        unsigned char c2; 
        unsigned char c3; 
        unsigned char c4; 
        unsigned char c5; 
        unsigned char c6; 
        unsigned char c7; 

        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Bat and Heading output 
        if ((line > 35) && (line < 43))
        {
                ltemp = (line - 36) * 27 - 64;
                ntemp = (line - 36) * 16 - 43;
                itemp = (line - 36) * 9; 
                ltr_p = ltrs+ltemp; 
                num_p = nums+ntemp; 
     84e:       ca 01           movw    r24, r20
     850:       82 95           swap    r24
     852:       92 95           swap    r25
     854:       90 7f           andi    r25, 0xF0       ; 240
     856:       98 27           eor     r25, r24
     858:       80 7f           andi    r24, 0xF0       ; 240
     85a:       98 27           eor     r25, r24
     85c:       bc 01           movw    r22, r24
     85e:       6f 55           subi    r22, 0x5F       ; 95
     860:       7f 4f           sbci    r23, 0xFF       ; 255
                info_p = infos+itemp; 
     862:       ca 01           movw    r24, r20
     864:       88 0f           add     r24, r24
     866:       99 1f           adc     r25, r25
     868:       88 0f           add     r24, r24
     86a:       99 1f           adc     r25, r25
     86c:       88 0f           add     r24, r24
     86e:       99 1f           adc     r25, r25
     870:       84 0f           add     r24, r20
     872:       95 1f           adc     r25, r21
     874:       9c 01           movw    r18, r24
     876:       28 5c           subi    r18, 0xC8       ; 200
     878:       3d 4f           sbci    r19, 0xFD       ; 253
                // +++ Bat 
                while(TCNT0<LINESTART);
     87a:       86 b5           in      r24, 0x26       ; 38
     87c:       88 3c           cpi     r24, 0xC8       ; 200
     87e:       e8 f3           brcs    .-6             ; 0x87a <draw_line+0x3e>
                TCNT0=0;
     880:       16 bc           out     0x26, r1        ; 38
                SPSR=1;
     882:       81 e0           ldi     r24, 0x01       ; 1
     884:       8d bd           out     0x2d, r24       ; 45
                
                DDRB|=1;                        //sink thru PB0
     886:       20 9a           sbi     0x04, 0 ; 4
                SPDR = info_p[bat[0]]; Wait();
     888:       80 91 10 01     lds     r24, 0x0110
     88c:       f9 01           movw    r30, r18
     88e:       e8 0f           add     r30, r24
     890:       f1 1d           adc     r31, r1
     892:       80 81           ld      r24, Z
     894:       8e bd           out     0x2e, r24       ; 46
     896:       0d b4           in      r0, 0x2d        ; 45
     898:       07 fe           sbrs    r0, 7
     89a:       fd cf           rjmp    .-6             ; 0x896 <draw_line+0x5a>
                SPDR = info_p[bat[1]]; Wait();
     89c:       80 91 11 01     lds     r24, 0x0111
     8a0:       f9 01           movw    r30, r18
     8a2:       e8 0f           add     r30, r24
     8a4:       f1 1d           adc     r31, r1
     8a6:       80 81           ld      r24, Z
     8a8:       8e bd           out     0x2e, r24       ; 46
     8aa:       0d b4           in      r0, 0x2d        ; 45
     8ac:       07 fe           sbrs    r0, 7
     8ae:       fd cf           rjmp    .-6             ; 0x8aa <draw_line+0x6e>
                SPDR = info_p[bat[2]]; Wait();
     8b0:       80 91 12 01     lds     r24, 0x0112
     8b4:       f9 01           movw    r30, r18
     8b6:       e8 0f           add     r30, r24
     8b8:       f1 1d           adc     r31, r1
     8ba:       80 81           ld      r24, Z
     8bc:       8e bd           out     0x2e, r24       ; 46
     8be:       0d b4           in      r0, 0x2d        ; 45
     8c0:       07 fe           sbrs    r0, 7
     8c2:       fd cf           rjmp    .-6             ; 0x8be <draw_line+0x82>
                SPDR = info_p[bat[3]]; Wait();
     8c4:       80 91 13 01     lds     r24, 0x0113
     8c8:       f9 01           movw    r30, r18
     8ca:       e8 0f           add     r30, r24
     8cc:       f1 1d           adc     r31, r1
     8ce:       80 81           ld      r24, Z
     8d0:       8e bd           out     0x2e, r24       ; 46
     8d2:       0d b4           in      r0, 0x2d        ; 45
     8d4:       07 fe           sbrs    r0, 7
     8d6:       fd cf           rjmp    .-6             ; 0x8d2 <draw_line+0x96>
                SPDR = info_p[bat[4]]; Wait();
     8d8:       80 91 14 01     lds     r24, 0x0114
     8dc:       f9 01           movw    r30, r18
     8de:       e8 0f           add     r30, r24
     8e0:       f1 1d           adc     r31, r1
     8e2:       80 81           ld      r24, Z
     8e4:       8e bd           out     0x2e, r24       ; 46
     8e6:       0d b4           in      r0, 0x2d        ; 45
     8e8:       07 fe           sbrs    r0, 7
     8ea:       fd cf           rjmp    .-6             ; 0x8e6 <draw_line+0xaa>
                SPDR = info_p[bat[5]]; Wait();
     8ec:       80 91 15 01     lds     r24, 0x0115
     8f0:       f9 01           movw    r30, r18
     8f2:       e8 0f           add     r30, r24
     8f4:       f1 1d           adc     r31, r1
     8f6:       80 81           ld      r24, Z
     8f8:       8e bd           out     0x2e, r24       ; 46
     8fa:       0d b4           in      r0, 0x2d        ; 45
     8fc:       07 fe           sbrs    r0, 7
     8fe:       fd cf           rjmp    .-6             ; 0x8fa <draw_line+0xbe>
                SPDR = info_p[bat[6]]; Wait();
     900:       80 91 16 01     lds     r24, 0x0116
     904:       f9 01           movw    r30, r18
     906:       e8 0f           add     r30, r24
     908:       f1 1d           adc     r31, r1
     90a:       80 81           ld      r24, Z
     90c:       8e bd           out     0x2e, r24       ; 46
     90e:       0d b4           in      r0, 0x2d        ; 45
     910:       07 fe           sbrs    r0, 7
     912:       fd cf           rjmp    .-6             ; 0x90e <draw_line+0xd2>
                SPDR = info_p[bat[7]]; Wait();
     914:       80 91 17 01     lds     r24, 0x0117
     918:       f9 01           movw    r30, r18
     91a:       e8 0f           add     r30, r24
     91c:       f1 1d           adc     r31, r1
     91e:       80 81           ld      r24, Z
     920:       8e bd           out     0x2e, r24       ; 46
     922:       0d b4           in      r0, 0x2d        ; 45
     924:       07 fe           sbrs    r0, 7
     926:       fd cf           rjmp    .-6             ; 0x922 <draw_line+0xe6>
                DDRB&=0xFE;             //PB0 Hi-Z again, and load a blank so spacing is right
     928:       20 98           cbi     0x04, 0 ; 4
                
                // +++ Heading 
                TCNT0=0; 
     92a:       16 bc           out     0x26, r1        ; 38
                while(TCNT0<80);
     92c:       86 b5           in      r24, 0x26       ; 38
     92e:       80 35           cpi     r24, 0x50       ; 80
     930:       e8 f3           brcs    .-6             ; 0x92c <draw_line+0xf0>
                TCNT0=0;
     932:       16 bc           out     0x26, r1        ; 38
                SPSR=0;
     934:       1d bc           out     0x2d, r1        ; 45
                DDRB|=1; 
     936:       20 9a           sbi     0x04, 0 ; 4
                SPDR = info_p[heading[0]]; Wait();
     938:       80 91 0b 01     lds     r24, 0x010B
     93c:       f9 01           movw    r30, r18
     93e:       e8 0f           add     r30, r24
     940:       f1 1d           adc     r31, r1
     942:       80 81           ld      r24, Z
     944:       8e bd           out     0x2e, r24       ; 46
     946:       0d b4           in      r0, 0x2d        ; 45
     948:       07 fe           sbrs    r0, 7
     94a:       fd cf           rjmp    .-6             ; 0x946 <draw_line+0x10a>
                SPDR = num_p[heading[1]]; Wait();
     94c:       80 91 0c 01     lds     r24, 0x010C
     950:       fb 01           movw    r30, r22
     952:       e8 0f           add     r30, r24
     954:       f1 1d           adc     r31, r1
     956:       80 81           ld      r24, Z
     958:       8e bd           out     0x2e, r24       ; 46
     95a:       0d b4           in      r0, 0x2d        ; 45
     95c:       07 fe           sbrs    r0, 7
     95e:       fd cf           rjmp    .-6             ; 0x95a <draw_line+0x11e>
                SPDR = num_p[heading[2]]; Wait();
     960:       80 91 0d 01     lds     r24, 0x010D
     964:       fb 01           movw    r30, r22
     966:       e8 0f           add     r30, r24
     968:       f1 1d           adc     r31, r1
     96a:       80 81           ld      r24, Z
     96c:       8e bd           out     0x2e, r24       ; 46
     96e:       0d b4           in      r0, 0x2d        ; 45
     970:       07 fe           sbrs    r0, 7
     972:       fd cf           rjmp    .-6             ; 0x96e <draw_line+0x132>
                SPDR = num_p[heading[3]]; Wait();
     974:       80 91 0e 01     lds     r24, 0x010E
     978:       fb 01           movw    r30, r22
     97a:       e8 0f           add     r30, r24
     97c:       f1 1d           adc     r31, r1
     97e:       80 81           ld      r24, Z
     980:       8e bd           out     0x2e, r24       ; 46
     982:       0d b4           in      r0, 0x2d        ; 45
     984:       07 fe           sbrs    r0, 7
     986:       fd cf           rjmp    .-6             ; 0x982 <draw_line+0x146>
                SPDR = info_p[heading[4]]; Wait();
     988:       80 91 0f 01     lds     r24, 0x010F
     98c:       f9 01           movw    r30, r18
     98e:       e8 0f           add     r30, r24
     990:       f1 1d           adc     r31, r1
     992:       80 81           ld      r24, Z
     994:       8e bd           out     0x2e, r24       ; 46
     996:       0d b4           in      r0, 0x2d        ; 45
     998:       07 fe           sbrs    r0, 7
     99a:       fd cf           rjmp    .-6             ; 0x996 <draw_line+0x15a>
                DDRB&=0xFE;             //PB0 Hi-Z again, and load a blank so spacing is right
     99c:       20 98           cbi     0x04, 0 ; 4
                
                // +++ RX Level
                while(TCNT0<250);  
     99e:       86 b5           in      r24, 0x26       ; 38
     9a0:       8a 3f           cpi     r24, 0xFA       ; 250
     9a2:       e8 f3           brcs    .-6             ; 0x99e <draw_line+0x162>
                TCNT0=0; 
     9a4:       16 bc           out     0x26, r1        ; 38
                while(TCNT0<70);  
     9a6:       86 b5           in      r24, 0x26       ; 38
     9a8:       86 34           cpi     r24, 0x46       ; 70
     9aa:       e8 f3           brcs    .-6             ; 0x9a6 <draw_line+0x16a>
                SPSR=1;
     9ac:       81 e0           ldi     r24, 0x01       ; 1
     9ae:       8d bd           out     0x2d, r24       ; 45
                DDRB|=1; 
     9b0:       20 9a           sbi     0x04, 0 ; 4
                SPDR = info_p[rx[0]]; Wait();
     9b2:       80 91 20 01     lds     r24, 0x0120
     9b6:       f9 01           movw    r30, r18
     9b8:       e8 0f           add     r30, r24
     9ba:       f1 1d           adc     r31, r1
     9bc:       80 81           ld      r24, Z
     9be:       8e bd           out     0x2e, r24       ; 46
     9c0:       0d b4           in      r0, 0x2d        ; 45
     9c2:       07 fe           sbrs    r0, 7
     9c4:       fd cf           rjmp    .-6             ; 0x9c0 <draw_line+0x184>
                SPDR = info_p[rx[1]]; Wait();
     9c6:       80 91 21 01     lds     r24, 0x0121
     9ca:       f9 01           movw    r30, r18
     9cc:       e8 0f           add     r30, r24
     9ce:       f1 1d           adc     r31, r1
     9d0:       80 81           ld      r24, Z
     9d2:       8e bd           out     0x2e, r24       ; 46
     9d4:       0d b4           in      r0, 0x2d        ; 45
     9d6:       07 fe           sbrs    r0, 7
     9d8:       fd cf           rjmp    .-6             ; 0x9d4 <draw_line+0x198>
                SPDR = info_p[rx[2]]; Wait();
     9da:       80 91 22 01     lds     r24, 0x0122
     9de:       f9 01           movw    r30, r18
     9e0:       e8 0f           add     r30, r24
     9e2:       f1 1d           adc     r31, r1
     9e4:       80 81           ld      r24, Z
     9e6:       8e bd           out     0x2e, r24       ; 46
     9e8:       0d b4           in      r0, 0x2d        ; 45
     9ea:       07 fe           sbrs    r0, 7
     9ec:       fd cf           rjmp    .-6             ; 0x9e8 <draw_line+0x1ac>
                SPDR = info_p[rx[3]]; Wait();
     9ee:       80 91 23 01     lds     r24, 0x0123
     9f2:       f9 01           movw    r30, r18
     9f4:       e8 0f           add     r30, r24
     9f6:       f1 1d           adc     r31, r1
     9f8:       80 81           ld      r24, Z
     9fa:       8e bd           out     0x2e, r24       ; 46
     9fc:       0d b4           in      r0, 0x2d        ; 45
     9fe:       07 fe           sbrs    r0, 7
     a00:       fd cf           rjmp    .-6             ; 0x9fc <draw_line+0x1c0>
                SPDR = info_p[rx[4]]; Wait();
     a02:       80 91 24 01     lds     r24, 0x0124
     a06:       f9 01           movw    r30, r18
     a08:       e8 0f           add     r30, r24
     a0a:       f1 1d           adc     r31, r1
     a0c:       80 81           ld      r24, Z
     a0e:       8e bd           out     0x2e, r24       ; 46
     a10:       0d b4           in      r0, 0x2d        ; 45
     a12:       07 fe           sbrs    r0, 7
     a14:       fd cf           rjmp    .-6             ; 0xa10 <draw_line+0x1d4>
                SPDR = info_p[rx[5]]; Wait();
     a16:       80 91 25 01     lds     r24, 0x0125
     a1a:       f9 01           movw    r30, r18
     a1c:       e8 0f           add     r30, r24
     a1e:       f1 1d           adc     r31, r1
     a20:       80 81           ld      r24, Z
     a22:       8e bd           out     0x2e, r24       ; 46
     a24:       0d b4           in      r0, 0x2d        ; 45
     a26:       07 fe           sbrs    r0, 7
     a28:       fd cf           rjmp    .-6             ; 0xa24 <draw_line+0x1e8>
                SPDR = info_p[rx[6]]; Wait();
     a2a:       80 91 26 01     lds     r24, 0x0126
     a2e:       f9 01           movw    r30, r18
     a30:       e8 0f           add     r30, r24
     a32:       f1 1d           adc     r31, r1
     a34:       80 81           ld      r24, Z
     a36:       8e bd           out     0x2e, r24       ; 46
     a38:       0d b4           in      r0, 0x2d        ; 45
     a3a:       07 fe           sbrs    r0, 7
     a3c:       fd cf           rjmp    .-6             ; 0xa38 <draw_line+0x1fc>
                SPDR = info_p[rx[7]]; Wait();
     a3e:       80 91 27 01     lds     r24, 0x0127
     a42:       f9 01           movw    r30, r18
     a44:       e8 0f           add     r30, r24
     a46:       f1 1d           adc     r31, r1
     a48:       80 81           ld      r24, Z
     a4a:       8e bd           out     0x2e, r24       ; 46
     a4c:       0d b4           in      r0, 0x2d        ; 45
     a4e:       07 fe           sbrs    r0, 7
     a50:       fd cf           rjmp    .-6             ; 0xa4c <draw_line+0x210>
                DDRB&=0xFE;     
     a52:       20 98           cbi     0x04, 0 ; 4
        }
        
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // UBat 
        if ((line > 44) && (line < 52))
     a54:       ca 01           movw    r24, r20
     a56:       8d 97           sbiw    r24, 0x2d       ; 45
     a58:       07 97           sbiw    r24, 0x07       ; 7
     a5a:       08 f0           brcs    .+2             ; 0xa5e <draw_line+0x222>
     a5c:       d4 c0           rjmp    .+424           ; 0xc06 <draw_line+0x3ca>
        {
                ltemp = (line - 45) * 27 - 64;
                ntemp = (line - 45) * 16 - 43;
                itemp = (line - 45) * 9; 
                ltr_p = ltrs+ltemp; 
     a5e:       ca 01           movw    r24, r20
     a60:       88 0f           add     r24, r24
     a62:       99 1f           adc     r25, r25
     a64:       84 0f           add     r24, r20
     a66:       95 1f           adc     r25, r21
     a68:       9c 01           movw    r18, r24
     a6a:       22 0f           add     r18, r18
     a6c:       33 1f           adc     r19, r19
     a6e:       22 0f           add     r18, r18
     a70:       33 1f           adc     r19, r19
     a72:       22 0f           add     r18, r18
     a74:       33 1f           adc     r19, r19
     a76:       82 0f           add     r24, r18
     a78:       93 1f           adc     r25, r19
     a7a:       bc 01           movw    r22, r24
     a7c:       60 5b           subi    r22, 0xB0       ; 176
     a7e:       72 40           sbci    r23, 0x02       ; 2
                num_p = nums+ntemp; 
     a80:       ca 01           movw    r24, r20
     a82:       82 95           swap    r24
     a84:       92 95           swap    r25
     a86:       90 7f           andi    r25, 0xF0       ; 240
     a88:       98 27           eor     r25, r24
     a8a:       80 7f           andi    r24, 0xF0       ; 240
     a8c:       98 27           eor     r25, r24
     a8e:       9c 01           movw    r18, r24
     a90:       2f 5e           subi    r18, 0xEF       ; 239
     a92:       3f 4f           sbci    r19, 0xFF       ; 255
                info_p = infos+itemp; 
                // +++ UBat 
                while(TCNT0<LINESTART); 
     a94:       86 b5           in      r24, 0x26       ; 38
     a96:       88 3c           cpi     r24, 0xC8       ; 200
     a98:       e8 f3           brcs    .-6             ; 0xa94 <draw_line+0x258>
                TCNT0=0; 
     a9a:       16 bc           out     0x26, r1        ; 38
                SPSR=1;
     a9c:       81 e0           ldi     r24, 0x01       ; 1
     a9e:       8d bd           out     0x2d, r24       ; 45
                DDRB|=1; 
     aa0:       20 9a           sbi     0x04, 0 ; 4
                SPDR = ltr_p[ubat[0]]; Wait();
     aa2:       80 91 18 01     lds     r24, 0x0118
     aa6:       fb 01           movw    r30, r22
     aa8:       e8 0f           add     r30, r24
     aaa:       f1 1d           adc     r31, r1
     aac:       80 81           ld      r24, Z
     aae:       8e bd           out     0x2e, r24       ; 46
     ab0:       0d b4           in      r0, 0x2d        ; 45
     ab2:       07 fe           sbrs    r0, 7
     ab4:       fd cf           rjmp    .-6             ; 0xab0 <draw_line+0x274>
                SPDR = num_p[ubat[1]]; Wait();
     ab6:       80 91 19 01     lds     r24, 0x0119
     aba:       f9 01           movw    r30, r18
     abc:       e8 0f           add     r30, r24
     abe:       f1 1d           adc     r31, r1
     ac0:       80 81           ld      r24, Z
     ac2:       8e bd           out     0x2e, r24       ; 46
     ac4:       0d b4           in      r0, 0x2d        ; 45
     ac6:       07 fe           sbrs    r0, 7
     ac8:       fd cf           rjmp    .-6             ; 0xac4 <draw_line+0x288>
                SPDR = ltr_p[ubat[2]]; Wait();
     aca:       80 91 1a 01     lds     r24, 0x011A
     ace:       fb 01           movw    r30, r22
     ad0:       e8 0f           add     r30, r24
     ad2:       f1 1d           adc     r31, r1
     ad4:       80 81           ld      r24, Z
     ad6:       8e bd           out     0x2e, r24       ; 46
     ad8:       0d b4           in      r0, 0x2d        ; 45
     ada:       07 fe           sbrs    r0, 7
     adc:       fd cf           rjmp    .-6             ; 0xad8 <draw_line+0x29c>
                SPDR = num_p[ubat[3]]; Wait();
     ade:       80 91 1b 01     lds     r24, 0x011B
     ae2:       f9 01           movw    r30, r18
     ae4:       e8 0f           add     r30, r24
     ae6:       f1 1d           adc     r31, r1
     ae8:       80 81           ld      r24, Z
     aea:       8e bd           out     0x2e, r24       ; 46
     aec:       0d b4           in      r0, 0x2d        ; 45
     aee:       07 fe           sbrs    r0, 7
     af0:       fd cf           rjmp    .-6             ; 0xaec <draw_line+0x2b0>
                SPDR = num_p[ubat[4]]; Wait();
     af2:       80 91 1c 01     lds     r24, 0x011C
     af6:       f9 01           movw    r30, r18
     af8:       e8 0f           add     r30, r24
     afa:       f1 1d           adc     r31, r1
     afc:       80 81           ld      r24, Z
     afe:       8e bd           out     0x2e, r24       ; 46
     b00:       0d b4           in      r0, 0x2d        ; 45
     b02:       07 fe           sbrs    r0, 7
     b04:       fd cf           rjmp    .-6             ; 0xb00 <draw_line+0x2c4>
                SPDR = num_p[ubat[5]]; Wait();
     b06:       80 91 1d 01     lds     r24, 0x011D
     b0a:       f9 01           movw    r30, r18
     b0c:       e8 0f           add     r30, r24
     b0e:       f1 1d           adc     r31, r1
     b10:       80 81           ld      r24, Z
     b12:       8e bd           out     0x2e, r24       ; 46
     b14:       0d b4           in      r0, 0x2d        ; 45
     b16:       07 fe           sbrs    r0, 7
     b18:       fd cf           rjmp    .-6             ; 0xb14 <draw_line+0x2d8>
                SPDR = num_p[ubat[6]]; Wait();
     b1a:       80 91 1e 01     lds     r24, 0x011E
     b1e:       f9 01           movw    r30, r18
     b20:       e8 0f           add     r30, r24
     b22:       f1 1d           adc     r31, r1
     b24:       80 81           ld      r24, Z
     b26:       8e bd           out     0x2e, r24       ; 46
     b28:       0d b4           in      r0, 0x2d        ; 45
     b2a:       07 fe           sbrs    r0, 7
     b2c:       fd cf           rjmp    .-6             ; 0xb28 <draw_line+0x2ec>
                SPDR = ltr_p[ubat[7]]; Wait();
     b2e:       80 91 1f 01     lds     r24, 0x011F
     b32:       fb 01           movw    r30, r22
     b34:       e8 0f           add     r30, r24
     b36:       f1 1d           adc     r31, r1
     b38:       80 81           ld      r24, Z
     b3a:       8e bd           out     0x2e, r24       ; 46
     b3c:       0d b4           in      r0, 0x2d        ; 45
     b3e:       07 fe           sbrs    r0, 7
     b40:       fd cf           rjmp    .-6             ; 0xb3c <draw_line+0x300>
                DDRB&=0xFE;             
     b42:       20 98           cbi     0x04, 0 ; 4
                TCNT0=0; 
     b44:       16 bc           out     0x26, r1        ; 38
                while(TCNT0<80); 
     b46:       86 b5           in      r24, 0x26       ; 38
     b48:       80 35           cpi     r24, 0x50       ; 80
     b4a:       e8 f3           brcs    .-6             ; 0xb46 <draw_line+0x30a>
                TCNT0=0; 
     b4c:       16 bc           out     0x26, r1        ; 38
                while(TCNT0<250);
     b4e:       86 b5           in      r24, 0x26       ; 38
     b50:       8a 3f           cpi     r24, 0xFA       ; 250
     b52:       e8 f3           brcs    .-6             ; 0xb4e <draw_line+0x312>
                TCNT0=0; 
     b54:       16 bc           out     0x26, r1        ; 38
                while(TCNT0<70);
     b56:       86 b5           in      r24, 0x26       ; 38
     b58:       86 34           cpi     r24, 0x46       ; 70
     b5a:       e8 f3           brcs    .-6             ; 0xb56 <draw_line+0x31a>
                TCNT0=0; 
     b5c:       16 bc           out     0x26, r1        ; 38
                SPSR=1;
     b5e:       81 e0           ldi     r24, 0x01       ; 1
     b60:       8d bd           out     0x2d, r24       ; 45
                DDRB|=1;
     b62:       20 9a           sbi     0x04, 0 ; 4
                SPDR = ltr_p[urx[0]]; Wait();
     b64:       80 91 28 01     lds     r24, 0x0128
     b68:       fb 01           movw    r30, r22
     b6a:       e8 0f           add     r30, r24
     b6c:       f1 1d           adc     r31, r1
     b6e:       80 81           ld      r24, Z
     b70:       8e bd           out     0x2e, r24       ; 46
     b72:       0d b4           in      r0, 0x2d        ; 45
     b74:       07 fe           sbrs    r0, 7
     b76:       fd cf           rjmp    .-6             ; 0xb72 <draw_line+0x336>
                SPDR = ltr_p[urx[1]]; Wait();
     b78:       80 91 29 01     lds     r24, 0x0129
     b7c:       fb 01           movw    r30, r22
     b7e:       e8 0f           add     r30, r24
     b80:       f1 1d           adc     r31, r1
     b82:       80 81           ld      r24, Z
     b84:       8e bd           out     0x2e, r24       ; 46
     b86:       0d b4           in      r0, 0x2d        ; 45
     b88:       07 fe           sbrs    r0, 7
     b8a:       fd cf           rjmp    .-6             ; 0xb86 <draw_line+0x34a>
                SPDR = num_p[urx[2]]; Wait();
     b8c:       80 91 2a 01     lds     r24, 0x012A
     b90:       f9 01           movw    r30, r18
     b92:       e8 0f           add     r30, r24
     b94:       f1 1d           adc     r31, r1
     b96:       80 81           ld      r24, Z
     b98:       8e bd           out     0x2e, r24       ; 46
     b9a:       0d b4           in      r0, 0x2d        ; 45
     b9c:       07 fe           sbrs    r0, 7
     b9e:       fd cf           rjmp    .-6             ; 0xb9a <draw_line+0x35e>
                SPDR = ltr_p[urx[3]]; Wait();
     ba0:       80 91 2b 01     lds     r24, 0x012B
     ba4:       fb 01           movw    r30, r22
     ba6:       e8 0f           add     r30, r24
     ba8:       f1 1d           adc     r31, r1
     baa:       80 81           ld      r24, Z
     bac:       8e bd           out     0x2e, r24       ; 46
     bae:       0d b4           in      r0, 0x2d        ; 45
     bb0:       07 fe           sbrs    r0, 7
     bb2:       fd cf           rjmp    .-6             ; 0xbae <draw_line+0x372>
                SPDR = num_p[urx[4]]; Wait();
     bb4:       80 91 2c 01     lds     r24, 0x012C
     bb8:       f9 01           movw    r30, r18
     bba:       e8 0f           add     r30, r24
     bbc:       f1 1d           adc     r31, r1
     bbe:       80 81           ld      r24, Z
     bc0:       8e bd           out     0x2e, r24       ; 46
     bc2:       0d b4           in      r0, 0x2d        ; 45
     bc4:       07 fe           sbrs    r0, 7
     bc6:       fd cf           rjmp    .-6             ; 0xbc2 <draw_line+0x386>
                SPDR = num_p[urx[5]]; Wait();
     bc8:       80 91 2d 01     lds     r24, 0x012D
     bcc:       f9 01           movw    r30, r18
     bce:       e8 0f           add     r30, r24
     bd0:       f1 1d           adc     r31, r1
     bd2:       80 81           ld      r24, Z
     bd4:       8e bd           out     0x2e, r24       ; 46
     bd6:       0d b4           in      r0, 0x2d        ; 45
     bd8:       07 fe           sbrs    r0, 7
     bda:       fd cf           rjmp    .-6             ; 0xbd6 <draw_line+0x39a>
                SPDR = num_p[urx[6]]; Wait();
     bdc:       80 91 2e 01     lds     r24, 0x012E
     be0:       f9 01           movw    r30, r18
     be2:       e8 0f           add     r30, r24
     be4:       f1 1d           adc     r31, r1
     be6:       80 81           ld      r24, Z
     be8:       8e bd           out     0x2e, r24       ; 46
     bea:       0d b4           in      r0, 0x2d        ; 45
     bec:       07 fe           sbrs    r0, 7
     bee:       fd cf           rjmp    .-6             ; 0xbea <draw_line+0x3ae>
                SPDR = num_p[urx[7]]; Wait();
     bf0:       80 91 2f 01     lds     r24, 0x012F
     bf4:       f9 01           movw    r30, r18
     bf6:       e8 0f           add     r30, r24
     bf8:       f1 1d           adc     r31, r1
     bfa:       80 81           ld      r24, Z
     bfc:       8e bd           out     0x2e, r24       ; 46
     bfe:       0d b4           in      r0, 0x2d        ; 45
     c00:       07 fe           sbrs    r0, 7
     c02:       fd cf           rjmp    .-6             ; 0xbfe <draw_line+0x3c2>
                DDRB&=0xFE;
     c04:       20 98           cbi     0x04, 0 ; 4
        
        }
        
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Message
        if ((line > 60) && (line < 68) && (showmessage1) && (lowbat))
     c06:       ca 01           movw    r24, r20
     c08:       cd 97           sbiw    r24, 0x3d       ; 61
     c0a:       07 97           sbiw    r24, 0x07       ; 7
     c0c:       08 f0           brcs    .+2             ; 0xc10 <draw_line+0x3d4>
     c0e:       9c c0           rjmp    .+312           ; 0xd48 <draw_line+0x50c>
     c10:       80 91 d9 03     lds     r24, 0x03D9
     c14:       88 23           and     r24, r24
     c16:       09 f4           brne    .+2             ; 0xc1a <draw_line+0x3de>
     c18:       97 c0           rjmp    .+302           ; 0xd48 <draw_line+0x50c>
     c1a:       80 91 d8 03     lds     r24, 0x03D8
     c1e:       88 23           and     r24, r24
     c20:       09 f4           brne    .+2             ; 0xc24 <draw_line+0x3e8>
     c22:       92 c0           rjmp    .+292           ; 0xd48 <draw_line+0x50c>
        {
                ltemp = (line - 61) * 27 - 64;
                ntemp = (line - 61) * 16 - 43;
                itemp = (line - 61) * 9; 
                ltr_p = ltrs+ltemp; 
     c24:       ca 01           movw    r24, r20
     c26:       88 0f           add     r24, r24
     c28:       99 1f           adc     r25, r25
     c2a:       84 0f           add     r24, r20
     c2c:       95 1f           adc     r25, r21
     c2e:       9c 01           movw    r18, r24
     c30:       22 0f           add     r18, r18
     c32:       33 1f           adc     r19, r19
     c34:       22 0f           add     r18, r18
     c36:       33 1f           adc     r19, r19
     c38:       22 0f           add     r18, r18
     c3a:       33 1f           adc     r19, r19
     c3c:       82 0f           add     r24, r18
     c3e:       93 1f           adc     r25, r19
     c40:       9c 01           movw    r18, r24
     c42:       20 56           subi    r18, 0x60       ; 96
     c44:       34 40           sbci    r19, 0x04       ; 4
                num_p = nums+ntemp; 
                info_p = infos+itemp; 
                // +++ UBat 
                while(TCNT0<LINESTART); 
     c46:       86 b5           in      r24, 0x26       ; 38
     c48:       88 3c           cpi     r24, 0xC8       ; 200
     c4a:       e8 f3           brcs    .-6             ; 0xc46 <draw_line+0x40a>
                TCNT0=0;
     c4c:       16 bc           out     0x26, r1        ; 38
                while(TCNT0<250);
     c4e:       86 b5           in      r24, 0x26       ; 38
     c50:       8a 3f           cpi     r24, 0xFA       ; 250
     c52:       e8 f3           brcs    .-6             ; 0xc4e <draw_line+0x412>
                SPSR=1;
     c54:       81 e0           ldi     r24, 0x01       ; 1
     c56:       8d bd           out     0x2d, r24       ; 45
                SPDR = ltr_p[Message_LowBat[0]]; Wait();
     c58:       f9 01           movw    r30, r18
     c5a:       e0 5c           subi    r30, 0xC0       ; 192
     c5c:       ff 4f           sbci    r31, 0xFF       ; 255
     c5e:       80 81           ld      r24, Z
     c60:       8e bd           out     0x2e, r24       ; 46
     c62:       0d b4           in      r0, 0x2d        ; 45
     c64:       07 fe           sbrs    r0, 7
     c66:       fd cf           rjmp    .-6             ; 0xc62 <draw_line+0x426>
                SPDR = ltr_p[Message_LowBat[1]]; Wait();
     c68:       f9 01           movw    r30, r18
     c6a:       e0 5c           subi    r30, 0xC0       ; 192
     c6c:       ff 4f           sbci    r31, 0xFF       ; 255
     c6e:       80 81           ld      r24, Z
     c70:       8e bd           out     0x2e, r24       ; 46
     c72:       0d b4           in      r0, 0x2d        ; 45
     c74:       07 fe           sbrs    r0, 7
     c76:       fd cf           rjmp    .-6             ; 0xc72 <draw_line+0x436>
                SPDR = ltr_p[Message_LowBat[2]]; Wait();
     c78:       f9 01           movw    r30, r18
     c7a:       e4 5b           subi    r30, 0xB4       ; 180
     c7c:       ff 4f           sbci    r31, 0xFF       ; 255
     c7e:       80 81           ld      r24, Z
     c80:       8e bd           out     0x2e, r24       ; 46
     c82:       0d b4           in      r0, 0x2d        ; 45
     c84:       07 fe           sbrs    r0, 7
     c86:       fd cf           rjmp    .-6             ; 0xc82 <draw_line+0x446>
                SPDR = ltr_p[Message_LowBat[3]]; Wait();
     c88:       f9 01           movw    r30, r18
     c8a:       e1 5b           subi    r30, 0xB1       ; 177
     c8c:       ff 4f           sbci    r31, 0xFF       ; 255
     c8e:       80 81           ld      r24, Z
     c90:       8e bd           out     0x2e, r24       ; 46
     c92:       0d b4           in      r0, 0x2d        ; 45
     c94:       07 fe           sbrs    r0, 7
     c96:       fd cf           rjmp    .-6             ; 0xc92 <draw_line+0x456>
                SPDR = ltr_p[Message_LowBat[4]]; Wait();
     c98:       f9 01           movw    r30, r18
     c9a:       e9 5a           subi    r30, 0xA9       ; 169
     c9c:       ff 4f           sbci    r31, 0xFF       ; 255
     c9e:       80 81           ld      r24, Z
     ca0:       8e bd           out     0x2e, r24       ; 46
     ca2:       0d b4           in      r0, 0x2d        ; 45
     ca4:       07 fe           sbrs    r0, 7
     ca6:       fd cf           rjmp    .-6             ; 0xca2 <draw_line+0x466>
                SPDR = ltr_p[Message_LowBat[5]]; Wait();
     ca8:       f9 01           movw    r30, r18
     caa:       e0 5c           subi    r30, 0xC0       ; 192
     cac:       ff 4f           sbci    r31, 0xFF       ; 255
     cae:       80 81           ld      r24, Z
     cb0:       8e bd           out     0x2e, r24       ; 46
     cb2:       0d b4           in      r0, 0x2d        ; 45
     cb4:       07 fe           sbrs    r0, 7
     cb6:       fd cf           rjmp    .-6             ; 0xcb2 <draw_line+0x476>
                SPDR = ltr_p[Message_LowBat[6]]; Wait();
     cb8:       f9 01           movw    r30, r18
     cba:       ee 5b           subi    r30, 0xBE       ; 190
     cbc:       ff 4f           sbci    r31, 0xFF       ; 255
     cbe:       80 81           ld      r24, Z
     cc0:       8e bd           out     0x2e, r24       ; 46
     cc2:       0d b4           in      r0, 0x2d        ; 45
     cc4:       07 fe           sbrs    r0, 7
     cc6:       fd cf           rjmp    .-6             ; 0xcc2 <draw_line+0x486>
                SPDR = ltr_p[Message_LowBat[7]]; Wait();
     cc8:       f9 01           movw    r30, r18
     cca:       ef 5b           subi    r30, 0xBF       ; 191
     ccc:       ff 4f           sbci    r31, 0xFF       ; 255
     cce:       80 81           ld      r24, Z
     cd0:       8e bd           out     0x2e, r24       ; 46
     cd2:       0d b4           in      r0, 0x2d        ; 45
     cd4:       07 fe           sbrs    r0, 7
     cd6:       fd cf           rjmp    .-6             ; 0xcd2 <draw_line+0x496>
                SPDR = ltr_p[Message_LowBat[8]]; Wait();
     cd8:       f9 01           movw    r30, r18
     cda:       ec 5a           subi    r30, 0xAC       ; 172
     cdc:       ff 4f           sbci    r31, 0xFF       ; 255
     cde:       80 81           ld      r24, Z
     ce0:       8e bd           out     0x2e, r24       ; 46
     ce2:       0d b4           in      r0, 0x2d        ; 45
     ce4:       07 fe           sbrs    r0, 7
     ce6:       fd cf           rjmp    .-6             ; 0xce2 <draw_line+0x4a6>
                SPDR = ltr_p[Message_LowBat[9]]; Wait();
     ce8:       f9 01           movw    r30, r18
     cea:       ec 5a           subi    r30, 0xAC       ; 172
     cec:       ff 4f           sbci    r31, 0xFF       ; 255
     cee:       80 81           ld      r24, Z
     cf0:       8e bd           out     0x2e, r24       ; 46
     cf2:       0d b4           in      r0, 0x2d        ; 45
     cf4:       07 fe           sbrs    r0, 7
     cf6:       fd cf           rjmp    .-6             ; 0xcf2 <draw_line+0x4b6>
                SPDR = ltr_p[Message_LowBat[10]]; Wait();
     cf8:       f9 01           movw    r30, r18
     cfa:       eb 5b           subi    r30, 0xBB       ; 187
     cfc:       ff 4f           sbci    r31, 0xFF       ; 255
     cfe:       80 81           ld      r24, Z
     d00:       8e bd           out     0x2e, r24       ; 46
     d02:       0d b4           in      r0, 0x2d        ; 45
     d04:       07 fe           sbrs    r0, 7
     d06:       fd cf           rjmp    .-6             ; 0xd02 <draw_line+0x4c6>
                SPDR = ltr_p[Message_LowBat[11]]; Wait();
     d08:       f9 01           movw    r30, r18
     d0a:       ee 5a           subi    r30, 0xAE       ; 174
     d0c:       ff 4f           sbci    r31, 0xFF       ; 255
     d0e:       80 81           ld      r24, Z
     d10:       8e bd           out     0x2e, r24       ; 46
     d12:       0d b4           in      r0, 0x2d        ; 45
     d14:       07 fe           sbrs    r0, 7
     d16:       fd cf           rjmp    .-6             ; 0xd12 <draw_line+0x4d6>
                SPDR = ltr_p[Message_LowBat[12]]; Wait();
     d18:       f9 01           movw    r30, r18
     d1a:       e7 5a           subi    r30, 0xA7       ; 167
     d1c:       ff 4f           sbci    r31, 0xFF       ; 255
     d1e:       80 81           ld      r24, Z
     d20:       8e bd           out     0x2e, r24       ; 46
     d22:       0d b4           in      r0, 0x2d        ; 45
     d24:       07 fe           sbrs    r0, 7
     d26:       fd cf           rjmp    .-6             ; 0xd22 <draw_line+0x4e6>
                SPDR = ltr_p[Message_LowBat[13]]; Wait();
     d28:       f9 01           movw    r30, r18
     d2a:       e0 5c           subi    r30, 0xC0       ; 192
     d2c:       ff 4f           sbci    r31, 0xFF       ; 255
     d2e:       80 81           ld      r24, Z
     d30:       8e bd           out     0x2e, r24       ; 46
     d32:       0d b4           in      r0, 0x2d        ; 45
     d34:       07 fe           sbrs    r0, 7
     d36:       fd cf           rjmp    .-6             ; 0xd32 <draw_line+0x4f6>
                SPDR = ltr_p[Message_LowBat[14]]; Wait();
     d38:       f9 01           movw    r30, r18
     d3a:       e0 5c           subi    r30, 0xC0       ; 192
     d3c:       ff 4f           sbci    r31, 0xFF       ; 255
     d3e:       80 81           ld      r24, Z
     d40:       8e bd           out     0x2e, r24       ; 46
     d42:       0d b4           in      r0, 0x2d        ; 45
     d44:       07 fe           sbrs    r0, 7
     d46:       fd cf           rjmp    .-6             ; 0xd42 <draw_line+0x506>
        }
        
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // alt value 
        
        if((line > 80) && (line <250))
     d48:       ca 01           movw    r24, r20
     d4a:       81 55           subi    r24, 0x51       ; 81
     d4c:       90 40           sbci    r25, 0x00       ; 0
     d4e:       89 3a           cpi     r24, 0xA9       ; 169
     d50:       91 05           cpc     r25, r1
     d52:       20 f4           brcc    .+8             ; 0xd5c <draw_line+0x520>
        {
                while(TCNT0<LINESTART);
     d54:       86 b5           in      r24, 0x26       ; 38
     d56:       88 3c           cpi     r24, 0xC8       ; 200
     d58:       e8 f3           brcs    .-6             ; 0xd54 <draw_line+0x518>
                TCNT0=0;
     d5a:       16 bc           out     0x26, r1        ; 38
        }

        if ((line > 170) && (line < 178))
     d5c:       ca 01           movw    r24, r20
     d5e:       8b 5a           subi    r24, 0xAB       ; 171
     d60:       90 40           sbci    r25, 0x00       ; 0
     d62:       07 97           sbiw    r24, 0x07       ; 7
     d64:       08 f0           brcs    .+2             ; 0xd68 <draw_line+0x52c>
     d66:       4d c0           rjmp    .+154           ; 0xe02 <draw_line+0x5c6>
        {
                ltemp = (line - 171) * 27 - 64;
                ntemp = (line - 171) * 16 - 43;
                itemp = (line - 171) * 9; 
                ltr_p = ltrs+ltemp; 
                num_p = nums+ntemp; 
     d68:       ca 01           movw    r24, r20
     d6a:       82 95           swap    r24
     d6c:       92 95           swap    r25
     d6e:       90 7f           andi    r25, 0xF0       ; 240
     d70:       98 27           eor     r25, r24
     d72:       80 7f           andi    r24, 0xF0       ; 240
     d74:       98 27           eor     r25, r24
     d76:       9c 01           movw    r18, r24
     d78:       2f 5c           subi    r18, 0xCF       ; 207
     d7a:       37 40           sbci    r19, 0x07       ; 7
                info_p = infos+itemp; 
                while(TCNT0<10);
     d7c:       86 b5           in      r24, 0x26       ; 38
     d7e:       8a 30           cpi     r24, 0x0A       ; 10
     d80:       e8 f3           brcs    .-6             ; 0xd7c <draw_line+0x540>
                SPSR=1;
     d82:       81 e0           ldi     r24, 0x01       ; 1
     d84:       8d bd           out     0x2d, r24       ; 45
                DDRB|=1; 
     d86:       20 9a           sbi     0x04, 0 ; 4
                SPDR = num_p[altv[0]]; Wait();
     d88:       80 91 30 01     lds     r24, 0x0130
     d8c:       f9 01           movw    r30, r18
     d8e:       e8 0f           add     r30, r24
     d90:       f1 1d           adc     r31, r1
     d92:       80 81           ld      r24, Z
     d94:       8e bd           out     0x2e, r24       ; 46
     d96:       0d b4           in      r0, 0x2d        ; 45
     d98:       07 fe           sbrs    r0, 7
     d9a:       fd cf           rjmp    .-6             ; 0xd96 <draw_line+0x55a>
                SPDR = num_p[altv[1]]; Wait();
     d9c:       80 91 31 01     lds     r24, 0x0131
     da0:       f9 01           movw    r30, r18
     da2:       e8 0f           add     r30, r24
     da4:       f1 1d           adc     r31, r1
     da6:       80 81           ld      r24, Z
     da8:       8e bd           out     0x2e, r24       ; 46
     daa:       0d b4           in      r0, 0x2d        ; 45
     dac:       07 fe           sbrs    r0, 7
     dae:       fd cf           rjmp    .-6             ; 0xdaa <draw_line+0x56e>
                SPDR = num_p[altv[2]]; Wait();
     db0:       80 91 32 01     lds     r24, 0x0132
     db4:       f9 01           movw    r30, r18
     db6:       e8 0f           add     r30, r24
     db8:       f1 1d           adc     r31, r1
     dba:       80 81           ld      r24, Z
     dbc:       8e bd           out     0x2e, r24       ; 46
     dbe:       0d b4           in      r0, 0x2d        ; 45
     dc0:       07 fe           sbrs    r0, 7
     dc2:       fd cf           rjmp    .-6             ; 0xdbe <draw_line+0x582>
                SPDR = num_p[altv[3]]; Wait();
     dc4:       80 91 33 01     lds     r24, 0x0133
     dc8:       f9 01           movw    r30, r18
     dca:       e8 0f           add     r30, r24
     dcc:       f1 1d           adc     r31, r1
     dce:       80 81           ld      r24, Z
     dd0:       8e bd           out     0x2e, r24       ; 46
     dd2:       0d b4           in      r0, 0x2d        ; 45
     dd4:       07 fe           sbrs    r0, 7
     dd6:       fd cf           rjmp    .-6             ; 0xdd2 <draw_line+0x596>
                SPDR = num_p[altv[4]]; Wait();
     dd8:       80 91 34 01     lds     r24, 0x0134
     ddc:       f9 01           movw    r30, r18
     dde:       e8 0f           add     r30, r24
     de0:       f1 1d           adc     r31, r1
     de2:       80 81           ld      r24, Z
     de4:       8e bd           out     0x2e, r24       ; 46
     de6:       0d b4           in      r0, 0x2d        ; 45
     de8:       07 fe           sbrs    r0, 7
     dea:       fd cf           rjmp    .-6             ; 0xde6 <draw_line+0x5aa>
                SPDR = num_p[altv[5]]; Wait();
     dec:       80 91 35 01     lds     r24, 0x0135
     df0:       f9 01           movw    r30, r18
     df2:       e8 0f           add     r30, r24
     df4:       f1 1d           adc     r31, r1
     df6:       80 81           ld      r24, Z
     df8:       8e bd           out     0x2e, r24       ; 46
     dfa:       0d b4           in      r0, 0x2d        ; 45
     dfc:       07 fe           sbrs    r0, 7
     dfe:       fd cf           rjmp    .-6             ; 0xdfa <draw_line+0x5be>
                DDRB&=0xFE;     
     e00:       20 98           cbi     0x04, 0 ; 4
        }

        if ((line > 179) && (line < (179 + alt_delta)) && alt_dec)
     e02:       44 3b           cpi     r20, 0xB4       ; 180
     e04:       51 05           cpc     r21, r1
     e06:       b0 f0           brcs    .+44            ; 0xe34 <draw_line+0x5f8>
     e08:       80 91 dc 03     lds     r24, 0x03DC
     e0c:       90 91 dd 03     lds     r25, 0x03DD
     e10:       8d 54           subi    r24, 0x4D       ; 77
     e12:       9f 4f           sbci    r25, 0xFF       ; 255
     e14:       48 17           cp      r20, r24
     e16:       59 07           cpc     r21, r25
     e18:       68 f4           brcc    .+26            ; 0xe34 <draw_line+0x5f8>
     e1a:       80 91 df 03     lds     r24, 0x03DF
     e1e:       88 23           and     r24, r24
     e20:       49 f0           breq    .+18            ; 0xe34 <draw_line+0x5f8>
        {
                while(TCNT0<50);
     e22:       86 b5           in      r24, 0x26       ; 38
     e24:       82 33           cpi     r24, 0x32       ; 50
     e26:       e8 f3           brcs    .-6             ; 0xe22 <draw_line+0x5e6>
                SPDR = bar1; Wait();
     e28:       80 91 36 01     lds     r24, 0x0136
     e2c:       8e bd           out     0x2e, r24       ; 46
     e2e:       0d b4           in      r0, 0x2d        ; 45
     e30:       07 fe           sbrs    r0, 7
     e32:       fd cf           rjmp    .-6             ; 0xe2e <draw_line+0x5f2>
        }

        if ((line > (169 - alt_delta)) && (line < 169) && alt_inc)
     e34:       40 91 ed 03     lds     r20, 0x03ED
     e38:       50 91 ee 03     lds     r21, 0x03EE
     e3c:       20 91 dc 03     lds     r18, 0x03DC
     e40:       30 91 dd 03     lds     r19, 0x03DD
     e44:       89 ea           ldi     r24, 0xA9       ; 169
     e46:       90 e0           ldi     r25, 0x00       ; 0
     e48:       82 1b           sub     r24, r18
     e4a:       93 0b           sbc     r25, r19
     e4c:       84 17           cp      r24, r20
     e4e:       95 07           cpc     r25, r21
     e50:       80 f4           brcc    .+32            ; 0xe72 <draw_line+0x636>
     e52:       49 3a           cpi     r20, 0xA9       ; 169
     e54:       51 05           cpc     r21, r1
     e56:       68 f4           brcc    .+26            ; 0xe72 <draw_line+0x636>
     e58:       80 91 de 03     lds     r24, 0x03DE
     e5c:       88 23           and     r24, r24
     e5e:       49 f0           breq    .+18            ; 0xe72 <draw_line+0x636>
        {
                while(TCNT0<50);
     e60:       86 b5           in      r24, 0x26       ; 38
     e62:       82 33           cpi     r24, 0x32       ; 50
     e64:       e8 f3           brcs    .-6             ; 0xe60 <draw_line+0x624>
                SPDR = bar1; Wait();
     e66:       80 91 36 01     lds     r24, 0x0136
     e6a:       8e bd           out     0x2e, r24       ; 46
     e6c:       0d b4           in      r0, 0x2d        ; 45
     e6e:       07 fe           sbrs    r0, 7
     e70:       fd cf           rjmp    .-6             ; 0xe6c <draw_line+0x630>
        }
    asm("nop");
     e72:       00 00           nop
        
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // grafic array 
        if ((line > 90) && (line < 250) && (showgraphic==1))
     e74:       ca 01           movw    r24, r20
     e76:       8b 55           subi    r24, 0x5B       ; 91
     e78:       90 40           sbci    r25, 0x00       ; 0
     e7a:       8f 39           cpi     r24, 0x9F       ; 159
     e7c:       91 05           cpc     r25, r1
     e7e:       08 f0           brcs    .+2             ; 0xe82 <draw_line+0x646>
     e80:       84 c0           rjmp    .+264           ; 0xf8a <draw_line+0x74e>
     e82:       80 91 00 01     lds     r24, 0x0100
     e86:       81 30           cpi     r24, 0x01       ; 1
     e88:       09 f0           breq    .+2             ; 0xe8c <draw_line+0x650>
     e8a:       7f c0           rjmp    .+254           ; 0xf8a <draw_line+0x74e>
        {

                while(TCNT0<250); 
     e8c:       86 b5           in      r24, 0x26       ; 38
     e8e:       8a 3f           cpi     r24, 0xFA       ; 250
     e90:       e8 f3           brcs    .-6             ; 0xe8c <draw_line+0x650>
                TCNT0=0;
     e92:       16 bc           out     0x26, r1        ; 38

                i1=7*((line-90)>>2);
     e94:       ca 01           movw    r24, r20
     e96:       8a 55           subi    r24, 0x5A       ; 90
     e98:       90 40           sbci    r25, 0x00       ; 0
     e9a:       96 95           lsr     r25
     e9c:       87 95           ror     r24
     e9e:       96 95           lsr     r25
     ea0:       87 95           ror     r24
     ea2:       fc 01           movw    r30, r24
     ea4:       ee 0f           add     r30, r30
     ea6:       ff 1f           adc     r31, r31
     ea8:       ee 0f           add     r30, r30
     eaa:       ff 1f           adc     r31, r31
     eac:       ee 0f           add     r30, r30
     eae:       ff 1f           adc     r31, r31
     eb0:       e8 1b           sub     r30, r24
     eb2:       f9 0b           sbc     r31, r25
                i=0;
                c1=dmem[i1++];
     eb4:       87 e3           ldi     r24, 0x37       ; 55
     eb6:       91 e0           ldi     r25, 0x01       ; 1
     eb8:       df 01           movw    r26, r30
     eba:       a8 0f           add     r26, r24
     ebc:       b9 1f           adc     r27, r25
     ebe:       4c 91           ld      r20, X
     ec0:       31 96           adiw    r30, 0x01       ; 1
                c2=dmem[i1++];
     ec2:       df 01           movw    r26, r30
     ec4:       a8 0f           add     r26, r24
     ec6:       b9 1f           adc     r27, r25
     ec8:       3c 91           ld      r19, X
     eca:       31 96           adiw    r30, 0x01       ; 1
                c3=dmem[i1++];
     ecc:       df 01           movw    r26, r30
     ece:       a8 0f           add     r26, r24
     ed0:       b9 1f           adc     r27, r25
     ed2:       5c 91           ld      r21, X
     ed4:       31 96           adiw    r30, 0x01       ; 1
                c4=dmem[i1++];
     ed6:       df 01           movw    r26, r30
     ed8:       a8 0f           add     r26, r24
     eda:       b9 1f           adc     r27, r25
     edc:       6c 91           ld      r22, X
     ede:       31 96           adiw    r30, 0x01       ; 1
                c5=dmem[i1++];
     ee0:       df 01           movw    r26, r30
     ee2:       a8 0f           add     r26, r24
     ee4:       b9 1f           adc     r27, r25
     ee6:       ac 91           ld      r26, X
     ee8:       31 96           adiw    r30, 0x01       ; 1
                c6=dmem[i1++];
     eea:       e8 0f           add     r30, r24
     eec:       f9 1f           adc     r31, r25
     eee:       70 81           ld      r23, Z
                c7=dmem[i1++];
     ef0:       91 81           ldd     r25, Z+1        ; 0x01
                while(TCNT0<20); 
     ef2:       86 b5           in      r24, 0x26       ; 38
     ef4:       84 31           cpi     r24, 0x14       ; 20
     ef6:       e8 f3           brcs    .-6             ; 0xef2 <draw_line+0x6b6>
                if (showgraphicb) DDRB|=1;
     ef8:       80 91 01 01     lds     r24, 0x0101
     efc:       88 23           and     r24, r24
     efe:       11 f4           brne    .+4             ; 0xf04 <draw_line+0x6c8>
     f00:       20 e0           ldi     r18, 0x00       ; 0
     f02:       02 c0           rjmp    .+4             ; 0xf08 <draw_line+0x6cc>
     f04:       20 9a           sbi     0x04, 0 ; 4
     f06:       20 e0           ldi     r18, 0x00       ; 0
                do {
                  PORTB=((c1<<2)&0x04);
     f08:       84 2f           mov     r24, r20
     f0a:       88 0f           add     r24, r24
     f0c:       88 0f           add     r24, r24
     f0e:       84 70           andi    r24, 0x04       ; 4
     f10:       85 b9           out     0x05, r24       ; 5
                  c1=c1>>1;
     f12:       46 95           lsr     r20
                  i++;
     f14:       2f 5f           subi    r18, 0xFF       ; 255
                } while(i<8);
     f16:       28 30           cpi     r18, 0x08       ; 8
     f18:       b9 f7           brne    .-18            ; 0xf08 <draw_line+0x6cc>
                do {
                  PORTB=((c2<<2)&0x04);
     f1a:       83 2f           mov     r24, r19
     f1c:       88 0f           add     r24, r24
     f1e:       88 0f           add     r24, r24
     f20:       84 70           andi    r24, 0x04       ; 4
     f22:       85 b9           out     0x05, r24       ; 5
                  c2=c2>>1;
     f24:       36 95           lsr     r19
                  i++;
     f26:       2f 5f           subi    r18, 0xFF       ; 255
                } while(i<16);
     f28:       20 31           cpi     r18, 0x10       ; 16
     f2a:       b9 f7           brne    .-18            ; 0xf1a <draw_line+0x6de>
                do {
                  PORTB=((c3<<2)&0x04);
     f2c:       85 2f           mov     r24, r21
     f2e:       88 0f           add     r24, r24
     f30:       88 0f           add     r24, r24
     f32:       84 70           andi    r24, 0x04       ; 4
     f34:       85 b9           out     0x05, r24       ; 5
                  c3=c3>>1;
     f36:       56 95           lsr     r21
                  i++;
     f38:       2f 5f           subi    r18, 0xFF       ; 255
                } while(i<24);
     f3a:       28 31           cpi     r18, 0x18       ; 24
     f3c:       b9 f7           brne    .-18            ; 0xf2c <draw_line+0x6f0>
                do {
                  PORTB=((c4<<2)&0x04);
     f3e:       86 2f           mov     r24, r22
     f40:       88 0f           add     r24, r24
     f42:       88 0f           add     r24, r24
     f44:       84 70           andi    r24, 0x04       ; 4
     f46:       85 b9           out     0x05, r24       ; 5
                  c4=c4>>1;
     f48:       66 95           lsr     r22
                  i++;
     f4a:       2f 5f           subi    r18, 0xFF       ; 255
                } while(i<32);
     f4c:       20 32           cpi     r18, 0x20       ; 32
     f4e:       b9 f7           brne    .-18            ; 0xf3e <draw_line+0x702>
                do {
                  PORTB=((c5<<2)&0x04);
     f50:       8a 2f           mov     r24, r26
     f52:       88 0f           add     r24, r24
     f54:       88 0f           add     r24, r24
     f56:       84 70           andi    r24, 0x04       ; 4
     f58:       85 b9           out     0x05, r24       ; 5
                  c5=c5>>1;
     f5a:       a6 95           lsr     r26
                  i++;
     f5c:       2f 5f           subi    r18, 0xFF       ; 255
                } while(i<40);
     f5e:       28 32           cpi     r18, 0x28       ; 40
     f60:       b9 f7           brne    .-18            ; 0xf50 <draw_line+0x714>
                do {
                  PORTB=((c6<<2)&0x04);
     f62:       87 2f           mov     r24, r23
     f64:       88 0f           add     r24, r24
     f66:       88 0f           add     r24, r24
     f68:       84 70           andi    r24, 0x04       ; 4
     f6a:       85 b9           out     0x05, r24       ; 5
                  c6=c6>>1;
     f6c:       76 95           lsr     r23
                  i++;
     f6e:       2f 5f           subi    r18, 0xFF       ; 255
                } while(i<48);
     f70:       20 33           cpi     r18, 0x30       ; 48
     f72:       b9 f7           brne    .-18            ; 0xf62 <draw_line+0x726>
                do {
                  PORTB=((c7<<2)&0x04);
     f74:       89 2f           mov     r24, r25
     f76:       88 0f           add     r24, r24
     f78:       88 0f           add     r24, r24
     f7a:       84 70           andi    r24, 0x04       ; 4
     f7c:       85 b9           out     0x05, r24       ; 5
                  c7=c7>>1;
     f7e:       96 95           lsr     r25
                  i++;
     f80:       2f 5f           subi    r18, 0xFF       ; 255
                } while(i<56);
     f82:       28 33           cpi     r18, 0x38       ; 56
     f84:       b9 f7           brne    .-18            ; 0xf74 <draw_line+0x738>
                PORTB=0x00; 
     f86:       15 b8           out     0x05, r1        ; 5
                DDRB&=0xFE;             
     f88:       20 98           cbi     0x04, 0 ; 4
        } 


// Debug - remove for release
//      if ((line > 270) && (line < 278))
//      {
//              SPSR=1;
//              ltemp = (line - 271) * 27 - 64;
//              ntemp = (line - 271) * 16 - 43;
//              itemp = (line - 271) * 8; 
//              ltr_p = ltrs+ltemp; 
//              num_p = nums+ntemp; 
//              info_p = infos+itemp; 
//              while(TCNT0<LINESTART); 
//              DDRB|=1; //sink thru PB0
//              SPDR = ltr_p[rxtx[0]]; Wait();
//              SPDR = ltr_p[rxtx[1]]; Wait();
//              SPDR = ltr_p[rxtx[2]]; Wait();
//              SPDR = info_p[rxtx[3]]; Wait();
//              SPDR = ltr_p[rxtx[4]]; Wait();
//              SPDR = ltr_p[rxtx[5]]; Wait();
//              SPDR = ltr_p[rxtx[6]]; Wait();
//              SPDR = ltr_p[rxtx[7]]; Wait();
//              SPDR = info_p[rxtx[8]]; Wait();
//              TCNT0=0;
//              while(TCNT0<3);         // 3 wait a little bit before turning off dimmer so that the
//                                                      // length of black box on the right matches the one on the left
//              DDRB&=0xFE;             //PB0 Hi-Z again, and load a blank so spacing is right
//      }
        

//      if ((line > 280) && (line < 288))
//      {
//              SPSR=1;
//              ltemp = (line - 281) * 27 - 64;
//              ntemp = (line - 281) * 16 - 43;
//              ltr_p = ltrs+ltemp;     //by calculating this pointer you only have to
//              num_p = nums+ntemp;     //add ltemp/ntemp once per line, instead of for
                                                                //every char. This tightens up printing a bit
                                                                //saves about 3 assembly instructions per char
                
//              SPDR = ltr_p['@']; Wait(); //goofy hack to make SPSR=0 work, write an empty char at SPSR=1 first
//              SPSR=1;
//              while(TCNT0<LINESTART); 
//              DDRB|=1; //sink thru PB0
//              //;display_line1[0]='A';
//              SPDR = ltr_p[display_line1[0]]; Wait();
//              SPDR = ltr_p[display_line1[1]]; Wait();
//              SPDR = ltr_p[display_line1[2]]; Wait();
//              SPDR = ltr_p[display_line1[3]]; Wait();
//              SPDR = ltr_p[display_line1[4]]; Wait();
//              SPDR = ltr_p[display_line1[5]]; Wait();
//              TCNT0=0;
//              while(TCNT0<3);         // 3 wait a little bit before turning off dimmer so that the
//                                                      // length of black box on the right matches the one on the left
//              DDRB&=0xFE;             //PB0 Hi-Z again, and load a blank so spacing is right
//      }
        
        if ((line > 300) && (line < 308))
     f8a:       20 91 ed 03     lds     r18, 0x03ED
     f8e:       30 91 ee 03     lds     r19, 0x03EE
     f92:       c9 01           movw    r24, r18
     f94:       8d 52           subi    r24, 0x2D       ; 45
     f96:       91 40           sbci    r25, 0x01       ; 1
     f98:       07 97           sbiw    r24, 0x07       ; 7
     f9a:       08 f0           brcs    .+2             ; 0xf9e <draw_line+0x762>
     f9c:       a2 c0           rjmp    .+324           ; 0x10e2 <draw_line+0x8a6>
        {
                SPSR=1;
     f9e:       81 e0           ldi     r24, 0x01       ; 1
     fa0:       8d bd           out     0x2d, r24       ; 45
                ltemp = (line - 301) * 27 - 64;
                ntemp = (line - 301) * 16 - 43;
                ltr_p = ltrs+ltemp;     
     fa2:       c9 01           movw    r24, r18
     fa4:       88 0f           add     r24, r24
     fa6:       99 1f           adc     r25, r25
     fa8:       82 0f           add     r24, r18
     faa:       93 1f           adc     r25, r19
     fac:       9c 01           movw    r18, r24
     fae:       22 0f           add     r18, r18
     fb0:       33 1f           adc     r19, r19
     fb2:       22 0f           add     r18, r18
     fb4:       33 1f           adc     r19, r19
     fb6:       22 0f           add     r18, r18
     fb8:       33 1f           adc     r19, r19
     fba:       82 0f           add     r24, r18
     fbc:       93 1f           adc     r25, r19
     fbe:       9c 01           movw    r18, r24
     fc0:       20 5b           subi    r18, 0xB0       ; 176
     fc2:       3d 41           sbci    r19, 0x1D       ; 29
                num_p = nums+ntemp;     
                while(TCNT0<LINESTART+COPYRIGHTSTART); 
     fc4:       86 b5           in      r24, 0x26       ; 38
     fc6:       88 3c           cpi     r24, 0xC8       ; 200
     fc8:       e8 f3           brcs    .-6             ; 0xfc4 <draw_line+0x788>
                SPDR = ltr_p[head[0]]; Wait();
     fca:       f9 01           movw    r30, r18
     fcc:       ed 5b           subi    r30, 0xBD       ; 189
     fce:       ff 4f           sbci    r31, 0xFF       ; 255
     fd0:       80 81           ld      r24, Z
     fd2:       8e bd           out     0x2e, r24       ; 46
     fd4:       0d b4           in      r0, 0x2d        ; 45
     fd6:       07 fe           sbrs    r0, 7
     fd8:       fd cf           rjmp    .-6             ; 0xfd4 <draw_line+0x798>
                SPDR = ltr_p[head[1]]; Wait();
     fda:       f9 01           movw    r30, r18
     fdc:       e0 5c           subi    r30, 0xC0       ; 192
     fde:       ff 4f           sbci    r31, 0xFF       ; 255
     fe0:       80 81           ld      r24, Z
     fe2:       8e bd           out     0x2e, r24       ; 46
     fe4:       0d b4           in      r0, 0x2d        ; 45
     fe6:       07 fe           sbrs    r0, 7
     fe8:       fd cf           rjmp    .-6             ; 0xfe4 <draw_line+0x7a8>
                SPDR = ltr_p[head[2]]; Wait();
     fea:       f9 01           movw    r30, r18
     fec:       e9 5b           subi    r30, 0xB9       ; 185
     fee:       ff 4f           sbci    r31, 0xFF       ; 255
     ff0:       80 81           ld      r24, Z
     ff2:       8e bd           out     0x2e, r24       ; 46
     ff4:       0d b4           in      r0, 0x2d        ; 45
     ff6:       07 fe           sbrs    r0, 7
     ff8:       fd cf           rjmp    .-6             ; 0xff4 <draw_line+0x7b8>
                SPDR = ltr_p[head[3]]; Wait();
     ffa:       f9 01           movw    r30, r18
     ffc:       eb 5a           subi    r30, 0xAB       ; 171
     ffe:       ff 4f           sbci    r31, 0xFF       ; 255
    1000:       80 81           ld      r24, Z
    1002:       8e bd           out     0x2e, r24       ; 46
    1004:       0d b4           in      r0, 0x2d        ; 45
    1006:       07 fe           sbrs    r0, 7
    1008:       fd cf           rjmp    .-6             ; 0x1004 <draw_line+0x7c8>
                SPDR = ltr_p[head[4]]; Wait();
    100a:       f9 01           movw    r30, r18
    100c:       e2 5b           subi    r30, 0xB2       ; 178
    100e:       ff 4f           sbci    r31, 0xFF       ; 255
    1010:       80 81           ld      r24, Z
    1012:       8e bd           out     0x2e, r24       ; 46
    1014:       0d b4           in      r0, 0x2d        ; 45
    1016:       07 fe           sbrs    r0, 7
    1018:       fd cf           rjmp    .-6             ; 0x1014 <draw_line+0x7d8>
                SPDR = ltr_p[head[5]]; Wait();
    101a:       f9 01           movw    r30, r18
    101c:       ec 5a           subi    r30, 0xAC       ; 172
    101e:       ff 4f           sbci    r31, 0xFF       ; 255
    1020:       80 81           ld      r24, Z
    1022:       8e bd           out     0x2e, r24       ; 46
    1024:       0d b4           in      r0, 0x2d        ; 45
    1026:       07 fe           sbrs    r0, 7
    1028:       fd cf           rjmp    .-6             ; 0x1024 <draw_line+0x7e8>
                SPDR = ltr_p[head[6]]; Wait();
    102a:       f9 01           movw    r30, r18
    102c:       eb 5b           subi    r30, 0xBB       ; 187
    102e:       ff 4f           sbci    r31, 0xFF       ; 255
    1030:       80 81           ld      r24, Z
    1032:       8e bd           out     0x2e, r24       ; 46
    1034:       0d b4           in      r0, 0x2d        ; 45
    1036:       07 fe           sbrs    r0, 7
    1038:       fd cf           rjmp    .-6             ; 0x1034 <draw_line+0x7f8>
                SPDR = ltr_p[head[7]]; Wait();
    103a:       f9 01           movw    r30, r18
    103c:       ee 5a           subi    r30, 0xAE       ; 174
    103e:       ff 4f           sbci    r31, 0xFF       ; 255
    1040:       80 81           ld      r24, Z
    1042:       8e bd           out     0x2e, r24       ; 46
    1044:       0d b4           in      r0, 0x2d        ; 45
    1046:       07 fe           sbrs    r0, 7
    1048:       fd cf           rjmp    .-6             ; 0x1044 <draw_line+0x808>
                SPDR = ltr_p[head[8]]; Wait();
    104a:       f9 01           movw    r30, r18
    104c:       e0 5c           subi    r30, 0xC0       ; 192
    104e:       ff 4f           sbci    r31, 0xFF       ; 255
    1050:       80 81           ld      r24, Z
    1052:       8e bd           out     0x2e, r24       ; 46
    1054:       0d b4           in      r0, 0x2d        ; 45
    1056:       07 fe           sbrs    r0, 7
    1058:       fd cf           rjmp    .-6             ; 0x1054 <draw_line+0x818>
                SPDR = ltr_p[head[9]]; Wait();
    105a:       f9 01           movw    r30, r18
    105c:       e4 5b           subi    r30, 0xB4       ; 180
    105e:       ff 4f           sbci    r31, 0xFF       ; 255
    1060:       80 81           ld      r24, Z
    1062:       8e bd           out     0x2e, r24       ; 46
    1064:       0d b4           in      r0, 0x2d        ; 45
    1066:       07 fe           sbrs    r0, 7
    1068:       fd cf           rjmp    .-6             ; 0x1064 <draw_line+0x828>
                SPDR = ltr_p[head[10]]; Wait();
    106a:       f9 01           movw    r30, r18
    106c:       e1 5b           subi    r30, 0xB1       ; 177
    106e:       ff 4f           sbci    r31, 0xFF       ; 255
    1070:       80 81           ld      r24, Z
    1072:       8e bd           out     0x2e, r24       ; 46
    1074:       0d b4           in      r0, 0x2d        ; 45
    1076:       07 fe           sbrs    r0, 7
    1078:       fd cf           rjmp    .-6             ; 0x1074 <draw_line+0x838>
                SPDR = ltr_p[head[11]]; Wait();
    107a:       f9 01           movw    r30, r18
    107c:       e9 5b           subi    r30, 0xB9       ; 185
    107e:       ff 4f           sbci    r31, 0xFF       ; 255
    1080:       80 81           ld      r24, Z
    1082:       8e bd           out     0x2e, r24       ; 46
    1084:       0d b4           in      r0, 0x2d        ; 45
    1086:       07 fe           sbrs    r0, 7
    1088:       fd cf           rjmp    .-6             ; 0x1084 <draw_line+0x848>
                SPDR = ltr_p[head[12]]; Wait();
    108a:       f9 01           movw    r30, r18
    108c:       eb 5b           subi    r30, 0xBB       ; 187
    108e:       ff 4f           sbci    r31, 0xFF       ; 255
    1090:       80 81           ld      r24, Z
    1092:       8e bd           out     0x2e, r24       ; 46
    1094:       0d b4           in      r0, 0x2d        ; 45
    1096:       07 fe           sbrs    r0, 7
    1098:       fd cf           rjmp    .-6             ; 0x1094 <draw_line+0x858>
                SPDR = ltr_p[head[13]]; Wait();
    109a:       f9 01           movw    r30, r18
    109c:       e3 5b           subi    r30, 0xB3       ; 179
    109e:       ff 4f           sbci    r31, 0xFF       ; 255
    10a0:       80 81           ld      r24, Z
    10a2:       8e bd           out     0x2e, r24       ; 46
    10a4:       0d b4           in      r0, 0x2d        ; 45
    10a6:       07 fe           sbrs    r0, 7
    10a8:       fd cf           rjmp    .-6             ; 0x10a4 <draw_line+0x868>
                SPDR = ltr_p[head[14]]; Wait();
    10aa:       f9 01           movw    r30, r18
    10ac:       ef 5b           subi    r30, 0xBF       ; 191
    10ae:       ff 4f           sbci    r31, 0xFF       ; 255
    10b0:       80 81           ld      r24, Z
    10b2:       8e bd           out     0x2e, r24       ; 46
    10b4:       0d b4           in      r0, 0x2d        ; 45
    10b6:       07 fe           sbrs    r0, 7
    10b8:       fd cf           rjmp    .-6             ; 0x10b4 <draw_line+0x878>
                SPDR = ltr_p[head[15]]; Wait();
    10ba:       f9 01           movw    r30, r18
    10bc:       e2 5b           subi    r30, 0xB2       ; 178
    10be:       ff 4f           sbci    r31, 0xFF       ; 255
    10c0:       80 81           ld      r24, Z
    10c2:       8e bd           out     0x2e, r24       ; 46
    10c4:       0d b4           in      r0, 0x2d        ; 45
    10c6:       07 fe           sbrs    r0, 7
    10c8:       fd cf           rjmp    .-6             ; 0x10c4 <draw_line+0x888>
                SPDR = ltr_p[head[16]]; Wait();
    10ca:       f9 01           movw    r30, r18
    10cc:       e2 5b           subi    r30, 0xB2       ; 178
    10ce:       ff 4f           sbci    r31, 0xFF       ; 255
    10d0:       80 81           ld      r24, Z
    10d2:       8e bd           out     0x2e, r24       ; 46
    10d4:       0d b4           in      r0, 0x2d        ; 45
    10d6:       07 fe           sbrs    r0, 7
    10d8:       fd cf           rjmp    .-6             ; 0x10d4 <draw_line+0x898>
                TCNT0=0;
    10da:       16 bc           out     0x26, r1        ; 38
                while(TCNT0<2);         
    10dc:       86 b5           in      r24, 0x26       ; 38
    10de:       82 30           cpi     r24, 0x02       ; 2
    10e0:       e8 f3           brcs    .-6             ; 0x10dc <draw_line+0x8a0>
    10e2:       08 95           ret

000010e4 <__vector_1>:
        }
} // end draw_line()


//-----------------------------------------------------------------------------
// H-Sync Interrupt
//-----------------------------------------------------------------------------*/
SIGNAL(SIG_INTERRUPT0)
{
    10e4:       1f 92           push    r1
    10e6:       0f 92           push    r0
    10e8:       0f b6           in      r0, 0x3f        ; 63
    10ea:       0f 92           push    r0
    10ec:       11 24           eor     r1, r1
    10ee:       2f 93           push    r18
    10f0:       3f 93           push    r19
    10f2:       4f 93           push    r20
    10f4:       5f 93           push    r21
    10f6:       6f 93           push    r22
    10f8:       7f 93           push    r23
    10fa:       8f 93           push    r24
    10fc:       9f 93           push    r25
    10fe:       af 93           push    r26
    1100:       bf 93           push    r27
    1102:       ef 93           push    r30
    1104:       ff 93           push    r31
        TCNT0=0;                // reset timer
    1106:       16 bc           out     0x26, r1        ; 38
        line++;                 // increment line counter 
    1108:       80 91 ed 03     lds     r24, 0x03ED
    110c:       90 91 ee 03     lds     r25, 0x03EE
    1110:       01 96           adiw    r24, 0x01       ; 1
    1112:       90 93 ee 03     sts     0x03EE, r25
    1116:       80 93 ed 03     sts     0x03ED, r24
        draw_line();    // output the line 
    111a:       90 db           rcall   .-2272          ; 0x83c <draw_line>
    111c:       ff 91           pop     r31
    111e:       ef 91           pop     r30
    1120:       bf 91           pop     r27
    1122:       af 91           pop     r26
    1124:       9f 91           pop     r25
    1126:       8f 91           pop     r24
    1128:       7f 91           pop     r23
    112a:       6f 91           pop     r22
    112c:       5f 91           pop     r21
    112e:       4f 91           pop     r20
    1130:       3f 91           pop     r19
    1132:       2f 91           pop     r18
    1134:       0f 90           pop     r0
    1136:       0f be           out     0x3f, r0        ; 63
    1138:       0f 90           pop     r0
    113a:       1f 90           pop     r1
    113c:       18 95           reti

0000113e <__vector_2>:
}       


//-----------------------------------------------------------------------------
// V-Sync Interrupt
//-----------------------------------------------------------------------------*/
SIGNAL(SIG_INTERRUPT1)
{
    113e:       1f 92           push    r1
    1140:       0f 92           push    r0
    1142:       0f b6           in      r0, 0x3f        ; 63
    1144:       0f 92           push    r0
    1146:       11 24           eor     r1, r1
    1148:       8f 93           push    r24
        line = 0;
    114a:       10 92 ee 03     sts     0x03EE, r1
    114e:       10 92 ed 03     sts     0x03ED, r1
        framecounter++;
    1152:       80 91 da 03     lds     r24, 0x03DA
    1156:       8f 5f           subi    r24, 0xFF       ; 255
    1158:       80 93 da 03     sts     0x03DA, r24
    115c:       8f 91           pop     r24
    115e:       0f 90           pop     r0
    1160:       0f be           out     0x3f, r0        ; 63
    1162:       0f 90           pop     r0
    1164:       1f 90           pop     r1
    1166:       18 95           reti

00001168 <__udivmodhi4>:
    1168:       aa 1b           sub     r26, r26
    116a:       bb 1b           sub     r27, r27
    116c:       51 e1           ldi     r21, 0x11       ; 17
    116e:       07 c0           rjmp    .+14            ; 0x117e <__udivmodhi4_ep>

00001170 <__udivmodhi4_loop>:
    1170:       aa 1f           adc     r26, r26
    1172:       bb 1f           adc     r27, r27
    1174:       a6 17           cp      r26, r22
    1176:       b7 07           cpc     r27, r23
    1178:       10 f0           brcs    .+4             ; 0x117e <__udivmodhi4_ep>
    117a:       a6 1b           sub     r26, r22
    117c:       b7 0b           sbc     r27, r23

0000117e <__udivmodhi4_ep>:
    117e:       88 1f           adc     r24, r24
    1180:       99 1f           adc     r25, r25
    1182:       5a 95           dec     r21
    1184:       a9 f7           brne    .-22            ; 0x1170 <__udivmodhi4_loop>
    1186:       80 95           com     r24
    1188:       90 95           com     r25
    118a:       bc 01           movw    r22, r24
    118c:       cd 01           movw    r24, r26
    118e:       08 95           ret

00001190 <__divmodhi4>:
    1190:       97 fb           bst     r25, 7
    1192:       09 2e           mov     r0, r25
    1194:       07 26           eor     r0, r23
    1196:       0a d0           rcall   .+20            ; 0x11ac <__divmodhi4_neg1>
    1198:       77 fd           sbrc    r23, 7
    119a:       04 d0           rcall   .+8             ; 0x11a4 <__divmodhi4_neg2>
    119c:       e5 df           rcall   .-54            ; 0x1168 <__udivmodhi4>
    119e:       06 d0           rcall   .+12            ; 0x11ac <__divmodhi4_neg1>
    11a0:       00 20           and     r0, r0
    11a2:       1a f4           brpl    .+6             ; 0x11aa <__divmodhi4_exit>

000011a4 <__divmodhi4_neg2>:
    11a4:       70 95           com     r23
    11a6:       61 95           neg     r22
    11a8:       7f 4f           sbci    r23, 0xFF       ; 255

000011aa <__divmodhi4_exit>:
    11aa:       08 95           ret

000011ac <__divmodhi4_neg1>:
    11ac:       f6 f7           brtc    .-4             ; 0x11aa <__divmodhi4_exit>
    11ae:       90 95           com     r25
    11b0:       81 95           neg     r24
    11b2:       9f 4f           sbci    r25, 0xFF       ; 255
    11b4:       08 95           ret

000011b6 <_exit>:
    11b6:       ff cf           rjmp    .-2             ; 0x11b6 <_exit>