It worked!!!
.ino code:
void setup() {
// put your setup code here, to run once:
int arranjo[5];
int* ponteiro = (int*) 0xF0F0;
ponteiro = arranjo;
Serial.begin(9600);
Serial.println(sizeof(arranjo));
Serial.println((long) arranjo);
Serial.println(sizeof(ponteiro));
Serial.println((long) ponteiro);
int a;
ponteiro = &a;
Serial.println(sizeof(ponteiro));
Serial.println((long) ponteiro);
while(!Serial.available());
a = (int) Serial.read();
int novo_arranjo[a];
Serial.println(sizeof(novo_arranjo));
Serial.println((long) novo_arranjo);
unsigned long longo_hex = 0x0FFFFFFF;
unsigned long longo_dec = 268435455;
float flutuante_hex = 0x0FFFFFFF;
float flutuante_dec = 268435455;
Serial.println();
Serial.println(longo_hex);
Serial.println(longo_dec);
Serial.println((float) longo_hex);
Serial.println((float) longo_dec);
Serial.println(flutuante_hex);
Serial.println(flutuante_dec);
Serial.println((long) flutuante_hex);
Serial.println((long) flutuante_dec);
}
void loop() {
// put your main code here, to run repeatedly:
}
The output:
sketch_jun29a.ino.elf: file format elf32-avr
Disassembly of section .text:
00000000 <__vectors>:
0: 0c 94 35 00 jmp 0x6a ; 0x6a <__ctors_end>
4: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
8: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
c: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
10: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
14: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
18: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
1c: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
20: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
24: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
28: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
2c: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
30: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
34: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
38: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
3c: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
40: 0c 94 27 02 jmp 0x44e ; 0x44e <__vector_16>
44: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
48: 0c 94 97 02 jmp 0x52e ; 0x52e <__vector_18>
4c: 0c 94 71 02 jmp 0x4e2 ; 0x4e2 <__vector_19>
50: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
54: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
58: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
5c: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
60: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
64: 0c 94 5d 00 jmp 0xba ; 0xba <__bad_interrupt>
00000068 <__ctors_start>:
68: d1 03 fmuls r21, r17
0000006a <__ctors_end>:
6a: 11 24 eor r1, r1
6c: 1f be out 0x3f, r1 ; 63
6e: cf ef ldi r28, 0xFF ; 255
70: d8 e0 ldi r29, 0x08 ; 8
72: de bf out 0x3e, r29 ; 62
74: cd bf out 0x3d, r28 ; 61
00000076 <__do_copy_data>:
76: 11 e0 ldi r17, 0x01 ; 1
78: a0 e0 ldi r26, 0x00 ; 0
7a: b1 e0 ldi r27, 0x01 ; 1
7c: e0 e5 ldi r30, 0x50 ; 80
7e: f8 e0 ldi r31, 0x08 ; 8
80: 02 c0 rjmp .+4 ; 0x86 <__do_copy_data+0x10>
82: 05 90 lpm r0, Z+
84: 0d 92 st X+, r0
86: a6 31 cpi r26, 0x16 ; 22
88: b1 07 cpc r27, r17
8a: d9 f7 brne .-10 ; 0x82 <__do_copy_data+0xc>
0000008c <__do_clear_bss>:
8c: 21 e0 ldi r18, 0x01 ; 1
8e: a6 e1 ldi r26, 0x16 ; 22
90: b1 e0 ldi r27, 0x01 ; 1
92: 01 c0 rjmp .+2 ; 0x96 <.do_clear_bss_start>
00000094 <.do_clear_bss_loop>:
94: 1d 92 st X+, r1
00000096 <.do_clear_bss_start>:
96: ac 3b cpi r26, 0xBC ; 188
98: b2 07 cpc r27, r18
9a: e1 f7 brne .-8 ; 0x94 <.do_clear_bss_loop>
0000009c <__do_global_ctors>:
9c: 10 e0 ldi r17, 0x00 ; 0
9e: c5 e3 ldi r28, 0x35 ; 53
a0: d0 e0 ldi r29, 0x00 ; 0
a2: 04 c0 rjmp .+8 ; 0xac <__do_global_ctors+0x10>
a4: 21 97 sbiw r28, 0x01 ; 1
a6: fe 01 movw r30, r28
a8: 0e 94 20 04 call 0x840 ; 0x840 <__tablejump2__>
ac: c4 33 cpi r28, 0x34 ; 52
ae: d1 07 cpc r29, r17
b0: c9 f7 brne .-14 ; 0xa4 <__do_global_ctors+0x8>
b2: 0e 94 c9 02 call 0x592 ; 0x592 <main>
b6: 0c 94 26 04 jmp 0x84c ; 0x84c <_exit>
000000ba <__bad_interrupt>:
ba: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>
000000be <Print::write(unsigned char const*, unsigned int)>:
// Public Methods //////////////////////////////////////////////////////////////
/* default implementation: may be overridden */
size_t Print::write(const uint8_t *buffer, size_t size)
{
be: af 92 push r10
c0: bf 92 push r11
c2: cf 92 push r12
c4: df 92 push r13
c6: ef 92 push r14
c8: ff 92 push r15
ca: 0f 93 push r16
cc: 1f 93 push r17
ce: cf 93 push r28
d0: df 93 push r29
d2: 6c 01 movw r12, r24
d4: 7b 01 movw r14, r22
d6: 8b 01 movw r16, r22
d8: 04 0f add r16, r20
da: 15 1f adc r17, r21
dc: eb 01 movw r28, r22
de: 5e 01 movw r10, r28
e0: ae 18 sub r10, r14
e2: bf 08 sbc r11, r15
size_t n = 0;
while (size--) {
e4: c0 17 cp r28, r16
e6: d1 07 cpc r29, r17
e8: 59 f0 breq .+22 ; 0x100 <Print::write(unsigned char const*, unsigned int)+0x42>
if (write(*buffer++)) n++;
ea: 69 91 ld r22, Y+
ec: d6 01 movw r26, r12
ee: ed 91 ld r30, X+
f0: fc 91 ld r31, X
f2: 01 90 ld r0, Z+
f4: f0 81 ld r31, Z
f6: e0 2d mov r30, r0
f8: c6 01 movw r24, r12
fa: 09 95 icall
fc: 89 2b or r24, r25
fe: 79 f7 brne .-34 ; 0xde <Print::write(unsigned char const*, unsigned int)+0x20>
else break;
}
return n;
}
100: c5 01 movw r24, r10
102: df 91 pop r29
104: cf 91 pop r28
106: 1f 91 pop r17
108: 0f 91 pop r16
10a: ff 90 pop r15
10c: ef 90 pop r14
10e: df 90 pop r13
110: cf 90 pop r12
112: bf 90 pop r11
114: af 90 pop r10
116: 08 95 ret
00000118 <HardwareSerial::availableForWrite()>:
{
tx_buffer_index_t head;
tx_buffer_index_t tail;
TX_BUFFER_ATOMIC {
head = _tx_buffer_head;
118: fc 01 movw r30, r24
11a: 53 8d ldd r21, Z+27 ; 0x1b
tail = _tx_buffer_tail;
11c: 44 8d ldd r20, Z+28 ; 0x1c
11e: 25 2f mov r18, r21
120: 30 e0 ldi r19, 0x00 ; 0
122: 84 2f mov r24, r20
124: 90 e0 ldi r25, 0x00 ; 0
}
if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail;
126: 82 1b sub r24, r18
128: 93 0b sbc r25, r19
12a: 54 17 cp r21, r20
12c: 10 f0 brcs .+4 ; 0x132 <HardwareSerial::availableForWrite()+0x1a>
12e: cf 96 adiw r24, 0x3f ; 63
130: 08 95 ret
return tail - head - 1;
132: 01 97 sbiw r24, 0x01 ; 1
}
134: 08 95 ret
00000136 <HardwareSerial::read()>:
return _rx_buffer[_rx_buffer_tail];
}
}
int HardwareSerial::read(void)
{
136: fc 01 movw r30, r24
// if the head isn't ahead of the tail, we don't have any characters
if (_rx_buffer_head == _rx_buffer_tail) {
138: 91 8d ldd r25, Z+25 ; 0x19
13a: 82 8d ldd r24, Z+26 ; 0x1a
13c: 98 17 cp r25, r24
13e: 61 f0 breq .+24 ; 0x158 <HardwareSerial::read()+0x22>
return -1;
} else {
unsigned char c = _rx_buffer[_rx_buffer_tail];
140: a2 8d ldd r26, Z+26 ; 0x1a
142: ae 0f add r26, r30
144: bf 2f mov r27, r31
146: b1 1d adc r27, r1
148: 5d 96 adiw r26, 0x1d ; 29
14a: 8c 91 ld r24, X
_rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE;
14c: 92 8d ldd r25, Z+26 ; 0x1a
14e: 9f 5f subi r25, 0xFF ; 255
150: 9f 73 andi r25, 0x3F ; 63
152: 92 8f std Z+26, r25 ; 0x1a
return c;
154: 90 e0 ldi r25, 0x00 ; 0
156: 08 95 ret
int HardwareSerial::read(void)
{
// if the head isn't ahead of the tail, we don't have any characters
if (_rx_buffer_head == _rx_buffer_tail) {
return -1;
158: 8f ef ldi r24, 0xFF ; 255
15a: 9f ef ldi r25, 0xFF ; 255
} else {
unsigned char c = _rx_buffer[_rx_buffer_tail];
_rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE;
return c;
}
}
15c: 08 95 ret
0000015e <HardwareSerial::peek()>:
{
return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE;
}
int HardwareSerial::peek(void)
{
15e: fc 01 movw r30, r24
if (_rx_buffer_head == _rx_buffer_tail) {
160: 91 8d ldd r25, Z+25 ; 0x19
162: 82 8d ldd r24, Z+26 ; 0x1a
164: 98 17 cp r25, r24
166: 31 f0 breq .+12 ; 0x174 <HardwareSerial::peek()+0x16>
return -1;
} else {
return _rx_buffer[_rx_buffer_tail];
168: 82 8d ldd r24, Z+26 ; 0x1a
16a: e8 0f add r30, r24
16c: f1 1d adc r31, r1
16e: 85 8d ldd r24, Z+29 ; 0x1d
170: 90 e0 ldi r25, 0x00 ; 0
172: 08 95 ret
}
int HardwareSerial::peek(void)
{
if (_rx_buffer_head == _rx_buffer_tail) {
return -1;
174: 8f ef ldi r24, 0xFF ; 255
176: 9f ef ldi r25, 0xFF ; 255
} else {
return _rx_buffer[_rx_buffer_tail];
}
}
178: 08 95 ret
0000017a <HardwareSerial::available()>:
// clear any received data
_rx_buffer_head = _rx_buffer_tail;
}
int HardwareSerial::available(void)
{
17a: fc 01 movw r30, r24
return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE;
17c: 91 8d ldd r25, Z+25 ; 0x19
17e: 22 8d ldd r18, Z+26 ; 0x1a
180: 89 2f mov r24, r25
182: 90 e0 ldi r25, 0x00 ; 0
184: 80 5c subi r24, 0xC0 ; 192
186: 9f 4f sbci r25, 0xFF ; 255
188: 82 1b sub r24, r18
18a: 91 09 sbc r25, r1
}
18c: 8f 73 andi r24, 0x3F ; 63
18e: 99 27 eor r25, r25
190: 08 95 ret
00000192 <Serial0_available()>:
#endif
// Function that can be weakly referenced by serialEventRun to prevent
// pulling in this file if it's not otherwise used.
bool Serial0_available() {
return Serial.available();
192: 8f e1 ldi r24, 0x1F ; 31
194: 91 e0 ldi r25, 0x01 ; 1
196: 0e 94 bd 00 call 0x17a ; 0x17a <HardwareSerial::available()>
19a: 21 e0 ldi r18, 0x01 ; 1
19c: 89 2b or r24, r25
19e: 09 f4 brne .+2 ; 0x1a2 <Serial0_available()+0x10>
1a0: 20 e0 ldi r18, 0x00 ; 0
}
1a2: 82 2f mov r24, r18
1a4: 08 95 ret
000001a6 <serialEventRun()>:
#endif
void serialEventRun(void)
{
#if defined(HAVE_HWSERIAL0)
if (Serial0_available && serialEvent && Serial0_available()) serialEvent();
1a6: 80 e0 ldi r24, 0x00 ; 0
1a8: 90 e0 ldi r25, 0x00 ; 0
1aa: 89 2b or r24, r25
1ac: 29 f0 breq .+10 ; 0x1b8 <serialEventRun()+0x12>
1ae: 0e 94 c9 00 call 0x192 ; 0x192 <Serial0_available()>
1b2: 81 11 cpse r24, r1
1b4: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>
if (Serial2_available && serialEvent2 && Serial2_available()) serialEvent2();
#endif
#if defined(HAVE_HWSERIAL3)
if (Serial3_available && serialEvent3 && Serial3_available()) serialEvent3();
#endif
}
1b8: 08 95 ret
000001ba <HardwareSerial::_tx_udr_empty_irq()>:
#endif
// Actual interrupt handlers //////////////////////////////////////////////////////////////
void HardwareSerial::_tx_udr_empty_irq(void)
{
1ba: fc 01 movw r30, r24
// If interrupts are enabled, there must be more data in the output
// buffer. Send the next byte
unsigned char c = _tx_buffer[_tx_buffer_tail];
1bc: a4 8d ldd r26, Z+28 ; 0x1c
1be: a8 0f add r26, r24
1c0: b9 2f mov r27, r25
1c2: b1 1d adc r27, r1
1c4: a3 5a subi r26, 0xA3 ; 163
1c6: bf 4f sbci r27, 0xFF ; 255
1c8: 2c 91 ld r18, X
_tx_buffer_tail = (_tx_buffer_tail + 1) % SERIAL_TX_BUFFER_SIZE;
1ca: 84 8d ldd r24, Z+28 ; 0x1c
1cc: 90 e0 ldi r25, 0x00 ; 0
1ce: 01 96 adiw r24, 0x01 ; 1
1d0: 8f 73 andi r24, 0x3F ; 63
1d2: 99 27 eor r25, r25
1d4: 84 8f std Z+28, r24 ; 0x1c
*_udr = c;
1d6: a6 89 ldd r26, Z+22 ; 0x16
1d8: b7 89 ldd r27, Z+23 ; 0x17
1da: 2c 93 st X, r18
// location". This makes sure flush() won't return until the bytes
// actually got written. Other r/w bits are preserved, and zeroes
// written to the rest.
#ifdef MPCM0
*_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << MPCM0))) | (1 << TXC0);
1dc: a0 89 ldd r26, Z+16 ; 0x10
1de: b1 89 ldd r27, Z+17 ; 0x11
1e0: 8c 91 ld r24, X
1e2: 83 70 andi r24, 0x03 ; 3
1e4: 80 64 ori r24, 0x40 ; 64
1e6: 8c 93 st X, r24
#else
*_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << TXC0)));
#endif
if (_tx_buffer_head == _tx_buffer_tail) {
1e8: 93 8d ldd r25, Z+27 ; 0x1b
1ea: 84 8d ldd r24, Z+28 ; 0x1c
1ec: 98 13 cpse r25, r24
1ee: 06 c0 rjmp .+12 ; 0x1fc <HardwareSerial::_tx_udr_empty_irq()+0x42>
// Buffer empty, so disable interrupts
cbi(*_ucsrb, UDRIE0);
1f0: 02 88 ldd r0, Z+18 ; 0x12
1f2: f3 89 ldd r31, Z+19 ; 0x13
1f4: e0 2d mov r30, r0
1f6: 80 81 ld r24, Z
1f8: 8f 7d andi r24, 0xDF ; 223
1fa: 80 83 st Z, r24
}
}
1fc: 08 95 ret
000001fe <HardwareSerial::write(unsigned char)>:
// If we get here, nothing is queued anymore (DRIE is disabled) and
// the hardware finished transmission (TXC is set).
}
size_t HardwareSerial::write(uint8_t c)
{
1fe: ef 92 push r14
200: ff 92 push r15
202: 0f 93 push r16
204: 1f 93 push r17
206: cf 93 push r28
208: df 93 push r29
20a: ec 01 movw r28, r24
_written = true;
20c: 81 e0 ldi r24, 0x01 ; 1
20e: 88 8f std Y+24, r24 ; 0x18
// If the buffer and the data register is empty, just write the byte
// to the data register and be done. This shortcut helps
// significantly improve the effective datarate at high (>
// 500kbit/s) bitrates, where interrupt overhead becomes a slowdown.
if (_tx_buffer_head == _tx_buffer_tail && bit_is_set(*_ucsra, UDRE0)) {
210: 9b 8d ldd r25, Y+27 ; 0x1b
212: 8c 8d ldd r24, Y+28 ; 0x1c
214: 98 13 cpse r25, r24
216: 1a c0 rjmp .+52 ; 0x24c <HardwareSerial::write(unsigned char)+0x4e>
218: e8 89 ldd r30, Y+16 ; 0x10
21a: f9 89 ldd r31, Y+17 ; 0x11
21c: 80 81 ld r24, Z
21e: 85 ff sbrs r24, 5
220: 15 c0 rjmp .+42 ; 0x24c <HardwareSerial::write(unsigned char)+0x4e>
// So writing UDR must happen first.
// Writing UDR and clearing TC must be done atomically, otherwise
// interrupts might delay the TXC clear so the byte written to UDR
// is transmitted (setting TXC) before clearing TXC. Then TXC will
// be cleared when no bytes are left, causing flush() to hang
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
222: 9f b7 in r25, 0x3f ; 63
return 1;
}
static __inline__ uint8_t __iCliRetVal(void)
{
cli();
224: f8 94 cli
*_udr = c;
226: ee 89 ldd r30, Y+22 ; 0x16
228: ff 89 ldd r31, Y+23 ; 0x17
22a: 60 83 st Z, r22
#ifdef MPCM0
*_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << MPCM0))) | (1 << TXC0);
22c: e8 89 ldd r30, Y+16 ; 0x10
22e: f9 89 ldd r31, Y+17 ; 0x11
230: 80 81 ld r24, Z
232: 83 70 andi r24, 0x03 ; 3
234: 80 64 ori r24, 0x40 ; 64
// make atomic to prevent execution of ISR between setting the
// head pointer and setting the interrupt flag resulting in buffer
// retransmission
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
_tx_buffer_head = i;
sbi(*_ucsrb, UDRIE0);
236: 80 83 st Z, r24
(void)__s;
}
static __inline__ void __iRestore(const uint8_t *__s)
{
SREG = *__s;
238: 9f bf out 0x3f, r25 ; 63
}
return 1;
}
23a: 81 e0 ldi r24, 0x01 ; 1
23c: 90 e0 ldi r25, 0x00 ; 0
23e: df 91 pop r29
240: cf 91 pop r28
242: 1f 91 pop r17
244: 0f 91 pop r16
246: ff 90 pop r15
248: ef 90 pop r14
24a: 08 95 ret
24c: f6 2e mov r15, r22
*_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << TXC0)));
#endif
}
return 1;
}
tx_buffer_index_t i = (_tx_buffer_head + 1) % SERIAL_TX_BUFFER_SIZE;
24e: 0b 8d ldd r16, Y+27 ; 0x1b
250: 10 e0 ldi r17, 0x00 ; 0
252: 0f 5f subi r16, 0xFF ; 255
254: 1f 4f sbci r17, 0xFF ; 255
256: 0f 73 andi r16, 0x3F ; 63
258: 11 27 eor r17, r17
25a: e0 2e mov r14, r16
// If the output buffer is full, there's nothing for it other than to
// wait for the interrupt handler to empty it a bit
while (i == _tx_buffer_tail) {
25c: 8c 8d ldd r24, Y+28 ; 0x1c
25e: 8e 11 cpse r24, r14
260: 0c c0 rjmp .+24 ; 0x27a <HardwareSerial::write(unsigned char)+0x7c>
if (bit_is_clear(SREG, SREG_I)) {
262: 0f b6 in r0, 0x3f ; 63
264: 07 fc sbrc r0, 7
266: fa cf rjmp .-12 ; 0x25c <HardwareSerial::write(unsigned char)+0x5e>
// Interrupts are disabled, so we'll have to poll the data
// register empty flag ourselves. If it is set, pretend an
// interrupt has happened and call the handler to free up
// space for us.
if(bit_is_set(*_ucsra, UDRE0))
268: e8 89 ldd r30, Y+16 ; 0x10
26a: f9 89 ldd r31, Y+17 ; 0x11
26c: 80 81 ld r24, Z
26e: 85 ff sbrs r24, 5
270: f5 cf rjmp .-22 ; 0x25c <HardwareSerial::write(unsigned char)+0x5e>
_tx_udr_empty_irq();
272: ce 01 movw r24, r28
274: 0e 94 dd 00 call 0x1ba ; 0x1ba <HardwareSerial::_tx_udr_empty_irq()>
278: f1 cf rjmp .-30 ; 0x25c <HardwareSerial::write(unsigned char)+0x5e>
} else {
// nop, the interrupt handler will free up space for us
}
}
_tx_buffer[_tx_buffer_head] = c;
27a: eb 8d ldd r30, Y+27 ; 0x1b
27c: ec 0f add r30, r28
27e: fd 2f mov r31, r29
280: f1 1d adc r31, r1
282: e3 5a subi r30, 0xA3 ; 163
284: ff 4f sbci r31, 0xFF ; 255
286: f0 82 st Z, r15
// make atomic to prevent execution of ISR between setting the
// head pointer and setting the interrupt flag resulting in buffer
// retransmission
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
288: 9f b7 in r25, 0x3f ; 63
return 1;
}
static __inline__ uint8_t __iCliRetVal(void)
{
cli();
28a: f8 94 cli
_tx_buffer_head = i;
28c: 0b 8f std Y+27, r16 ; 0x1b
sbi(*_ucsrb, UDRIE0);
28e: ea 89 ldd r30, Y+18 ; 0x12
290: fb 89 ldd r31, Y+19 ; 0x13
292: 80 81 ld r24, Z
294: 80 62 ori r24, 0x20 ; 32
296: cf cf rjmp .-98 ; 0x236 <HardwareSerial::write(unsigned char)+0x38>
00000298 <HardwareSerial::flush()>:
if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail;
return tail - head - 1;
}
void HardwareSerial::flush()
{
298: cf 93 push r28
29a: df 93 push r29
29c: ec 01 movw r28, r24
// If we have never written a byte, no need to flush. This special
// case is needed since there is no way to force the TXC (transmit
// complete) bit to 1 during initialization
if (!_written)
29e: 88 8d ldd r24, Y+24 ; 0x18
2a0: 88 23 and r24, r24
2a2: b9 f0 breq .+46 ; 0x2d2 <HardwareSerial::flush()+0x3a>
return;
while (bit_is_set(*_ucsrb, UDRIE0) || bit_is_clear(*_ucsra, TXC0)) {
2a4: aa 89 ldd r26, Y+18 ; 0x12
2a6: bb 89 ldd r27, Y+19 ; 0x13
2a8: e8 89 ldd r30, Y+16 ; 0x10
2aa: f9 89 ldd r31, Y+17 ; 0x11
2ac: 8c 91 ld r24, X
2ae: 85 fd sbrc r24, 5
2b0: 03 c0 rjmp .+6 ; 0x2b8 <HardwareSerial::flush()+0x20>
2b2: 80 81 ld r24, Z
2b4: 86 fd sbrc r24, 6
2b6: 0d c0 rjmp .+26 ; 0x2d2 <HardwareSerial::flush()+0x3a>
if (bit_is_clear(SREG, SREG_I) && bit_is_set(*_ucsrb, UDRIE0))
2b8: 0f b6 in r0, 0x3f ; 63
2ba: 07 fc sbrc r0, 7
2bc: f7 cf rjmp .-18 ; 0x2ac <HardwareSerial::flush()+0x14>
2be: 8c 91 ld r24, X
2c0: 85 ff sbrs r24, 5
2c2: f2 cf rjmp .-28 ; 0x2a8 <HardwareSerial::flush()+0x10>
// Interrupts are globally disabled, but the DR empty
// interrupt should be enabled, so poll the DR empty flag to
// prevent deadlock
if (bit_is_set(*_ucsra, UDRE0))
2c4: 80 81 ld r24, Z
2c6: 85 ff sbrs r24, 5
2c8: ed cf rjmp .-38 ; 0x2a4 <HardwareSerial::flush()+0xc>
_tx_udr_empty_irq();
2ca: ce 01 movw r24, r28
2cc: 0e 94 dd 00 call 0x1ba ; 0x1ba <HardwareSerial::_tx_udr_empty_irq()>
2d0: e9 cf rjmp .-46 ; 0x2a4 <HardwareSerial::flush()+0xc>
}
// If we get here, nothing is queued anymore (DRIE is disabled) and
// the hardware finished transmission (TXC is set).
}
2d2: df 91 pop r29
2d4: cf 91 pop r28
2d6: 08 95 ret
000002d8 <Print::write(char const*) [clone .part.2] [clone .constprop.18]>:
void clearWriteError() { setWriteError(0); }
virtual size_t write(uint8_t) = 0;
size_t write(const char *str) {
if (str == NULL) return 0;
return write((const uint8_t *)str, strlen(str));
2d8: fc 01 movw r30, r24
2da: 01 90 ld r0, Z+
2dc: 00 20 and r0, r0
2de: e9 f7 brne .-6 ; 0x2da <Print::write(char const*) [clone .part.2] [clone .constprop.18]+0x2>
2e0: 31 97 sbiw r30, 0x01 ; 1
2e2: af 01 movw r20, r30
2e4: 48 1b sub r20, r24
2e6: 59 0b sbc r21, r25
2e8: bc 01 movw r22, r24
2ea: 8f e1 ldi r24, 0x1F ; 31
2ec: 91 e0 ldi r25, 0x01 ; 1
2ee: 0c 94 5f 00 jmp 0xbe ; 0xbe <Print::write(unsigned char const*, unsigned int)>
000002f2 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.15]>:
return n;
}
// Private Methods /////////////////////////////////////////////////////////////
size_t Print::printNumber(unsigned long n, uint8_t base)
2f2: 8f 92 push r8
2f4: 9f 92 push r9
2f6: af 92 push r10
2f8: bf 92 push r11
2fa: 0f 93 push r16
2fc: 1f 93 push r17
2fe: cf 93 push r28
300: df 93 push r29
302: cd b7 in r28, 0x3d ; 61
304: de b7 in r29, 0x3e ; 62
306: a1 97 sbiw r28, 0x21 ; 33
308: 0f b6 in r0, 0x3f ; 63
30a: f8 94 cli
30c: de bf out 0x3e, r29 ; 62
30e: 0f be out 0x3f, r0 ; 63
310: cd bf out 0x3d, r28 ; 61
{
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
char *str = &buf[sizeof(buf) - 1];
*str = '\0';
312: 19 a2 std Y+33, r1 ; 0x21
// prevent crash if called with base == 1
if (base < 2) base = 10;
314: 42 30 cpi r20, 0x02 ; 2
316: 08 f4 brcc .+2 ; 0x31a <Print::printNumber(unsigned long, unsigned char) [clone .constprop.15]+0x28>
318: 4a e0 ldi r20, 0x0A ; 10
31a: 8e 01 movw r16, r28
31c: 0f 5d subi r16, 0xDF ; 223
31e: 1f 4f sbci r17, 0xFF ; 255
do {
char c = n % base;
320: 84 2e mov r8, r20
322: 91 2c mov r9, r1
324: b1 2c mov r11, r1
326: a1 2c mov r10, r1
328: a5 01 movw r20, r10
32a: 94 01 movw r18, r8
32c: 0e 94 fe 03 call 0x7fc ; 0x7fc <__udivmodsi4>
330: e6 2f mov r30, r22
n /= base;
332: b9 01 movw r22, r18
334: ca 01 movw r24, r20
*--str = c < 10 ? c + '0' : c + 'A' - 10;
336: ea 30 cpi r30, 0x0A ; 10
338: f4 f4 brge .+60 ; 0x376 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.15]+0x84>
33a: e0 5d subi r30, 0xD0 ; 208
33c: d8 01 movw r26, r16
33e: ee 93 st -X, r30
340: 8d 01 movw r16, r26
} while(n);
342: 23 2b or r18, r19
344: 24 2b or r18, r20
346: 25 2b or r18, r21
348: 79 f7 brne .-34 ; 0x328 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.15]+0x36>
int getWriteError() { return write_error; }
void clearWriteError() { setWriteError(0); }
virtual size_t write(uint8_t) = 0;
size_t write(const char *str) {
if (str == NULL) return 0;
34a: 90 e0 ldi r25, 0x00 ; 0
34c: 80 e0 ldi r24, 0x00 ; 0
34e: 10 97 sbiw r26, 0x00 ; 0
350: 19 f0 breq .+6 ; 0x358 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.15]+0x66>
352: cd 01 movw r24, r26
354: 0e 94 6c 01 call 0x2d8 ; 0x2d8 <Print::write(char const*) [clone .part.2] [clone .constprop.18]>
return write(str);
}
358: a1 96 adiw r28, 0x21 ; 33
35a: 0f b6 in r0, 0x3f ; 63
35c: f8 94 cli
35e: de bf out 0x3e, r29 ; 62
360: 0f be out 0x3f, r0 ; 63
362: cd bf out 0x3d, r28 ; 61
364: df 91 pop r29
366: cf 91 pop r28
368: 1f 91 pop r17
36a: 0f 91 pop r16
36c: bf 90 pop r11
36e: af 90 pop r10
370: 9f 90 pop r9
372: 8f 90 pop r8
374: 08 95 ret
do {
char c = n % base;
n /= base;
*--str = c < 10 ? c + '0' : c + 'A' - 10;
376: e9 5c subi r30, 0xC9 ; 201
378: e1 cf rjmp .-62 ; 0x33c <Print::printNumber(unsigned long, unsigned char) [clone .constprop.15]+0x4a>
0000037a <Print::println(long, int) [clone .constprop.11]>:
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long num, int base)
37a: cf 92 push r12
37c: df 92 push r13
37e: ef 92 push r14
380: ff 92 push r15
382: cf 93 push r28
384: df 93 push r29
386: 6b 01 movw r12, r22
388: 7c 01 movw r14, r24
size_t Print::print(long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
38a: f7 fe sbrs r15, 7
38c: 1f c0 rjmp .+62 ; 0x3cc <Print::println(long, int) [clone .constprop.11]+0x52>
return write(str);
}
size_t Print::print(char c)
{
return write(c);
38e: 6d e2 ldi r22, 0x2D ; 45
390: 8f e1 ldi r24, 0x1F ; 31
392: 91 e0 ldi r25, 0x01 ; 1
394: 0e 94 ff 00 call 0x1fe ; 0x1fe <HardwareSerial::write(unsigned char)>
398: ec 01 movw r28, r24
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
39a: 66 27 eor r22, r22
39c: 77 27 eor r23, r23
39e: cb 01 movw r24, r22
3a0: 6c 19 sub r22, r12
3a2: 7d 09 sbc r23, r13
3a4: 8e 09 sbc r24, r14
3a6: 9f 09 sbc r25, r15
return printNumber(n, 10) + t;
3a8: 4a e0 ldi r20, 0x0A ; 10
3aa: 0e 94 79 01 call 0x2f2 ; 0x2f2 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.15]>
3ae: c8 0f add r28, r24
3b0: d9 1f adc r29, r25
3b2: 82 e1 ldi r24, 0x12 ; 18
3b4: 91 e0 ldi r25, 0x01 ; 1
3b6: 0e 94 6c 01 call 0x2d8 ; 0x2d8 <Print::write(char const*) [clone .part.2] [clone .constprop.18]>
size_t Print::println(long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
3ba: 8c 0f add r24, r28
3bc: 9d 1f adc r25, r29
3be: df 91 pop r29
3c0: cf 91 pop r28
3c2: ff 90 pop r15
3c4: ef 90 pop r14
3c6: df 90 pop r13
3c8: cf 90 pop r12
3ca: 08 95 ret
if (n < 0) {
int t = print('-');
n = -n;
return printNumber(n, 10) + t;
}
return printNumber(n, 10);
3cc: 4a e0 ldi r20, 0x0A ; 10
3ce: 0e 94 79 01 call 0x2f2 ; 0x2f2 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.15]>
3d2: ec 01 movw r28, r24
3d4: ee cf rjmp .-36 ; 0x3b2 <Print::println(long, int) [clone .constprop.11]+0x38>
000003d6 <Print::println(unsigned int, int) [clone .constprop.3]>:
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned int num, int base)
3d6: cf 93 push r28
3d8: df 93 push r29
return print((long) n, base);
}
size_t Print::print(unsigned int n, int base)
{
return print((unsigned long) n, base);
3da: bc 01 movw r22, r24
3dc: 90 e0 ldi r25, 0x00 ; 0
3de: 80 e0 ldi r24, 0x00 ; 0
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
3e0: 4a e0 ldi r20, 0x0A ; 10
3e2: 0e 94 79 01 call 0x2f2 ; 0x2f2 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.15]>
3e6: ec 01 movw r28, r24
3e8: 82 e1 ldi r24, 0x12 ; 18
3ea: 91 e0 ldi r25, 0x01 ; 1
3ec: 0e 94 6c 01 call 0x2d8 ; 0x2d8 <Print::write(char const*) [clone .part.2] [clone .constprop.18]>
size_t Print::println(unsigned int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
3f0: 8c 0f add r24, r28
3f2: 9d 1f adc r25, r29
3f4: df 91 pop r29
3f6: cf 91 pop r28
3f8: 08 95 ret
000003fa <Print::println(double, int) [clone .constprop.5]>:
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(double num, int digits)
3fa: cf 93 push r28
3fc: df 93 push r29
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
3fe: 4a e0 ldi r20, 0x0A ; 10
400: 60 e0 ldi r22, 0x00 ; 0
402: 70 e0 ldi r23, 0x00 ; 0
404: 80 e0 ldi r24, 0x00 ; 0
406: 90 e1 ldi r25, 0x10 ; 16
408: 0e 94 79 01 call 0x2f2 ; 0x2f2 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.15]>
40c: ec 01 movw r28, r24
return write(str);
}
size_t Print::print(char c)
{
return write(c);
40e: 6e e2 ldi r22, 0x2E ; 46
410: 8f e1 ldi r24, 0x1F ; 31
412: 91 e0 ldi r25, 0x01 ; 1
414: 0e 94 ff 00 call 0x1fe ; 0x1fe <HardwareSerial::write(unsigned char)>
double remainder = number - (double)int_part;
n += print(int_part);
// Print the decimal point, but only if there are digits beyond
if (digits > 0) {
n += print('.');
418: c8 0f add r28, r24
41a: d9 1f adc r29, r25
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
41c: 4a e0 ldi r20, 0x0A ; 10
41e: 60 e0 ldi r22, 0x00 ; 0
420: 70 e0 ldi r23, 0x00 ; 0
422: cb 01 movw r24, r22
424: 0e 94 79 01 call 0x2f2 ; 0x2f2 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.15]>
// Extract digits from the remainder one at a time
while (digits-- > 0)
{
remainder *= 10.0;
unsigned int toPrint = (unsigned int)(remainder);
n += print(toPrint);
428: c8 0f add r28, r24
42a: d9 1f adc r29, r25
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
42c: 4a e0 ldi r20, 0x0A ; 10
42e: 60 e0 ldi r22, 0x00 ; 0
430: 70 e0 ldi r23, 0x00 ; 0
432: cb 01 movw r24, r22
434: 0e 94 79 01 call 0x2f2 ; 0x2f2 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.15]>
// Extract digits from the remainder one at a time
while (digits-- > 0)
{
remainder *= 10.0;
unsigned int toPrint = (unsigned int)(remainder);
n += print(toPrint);
438: c8 0f add r28, r24
43a: d9 1f adc r29, r25
43c: 82 e1 ldi r24, 0x12 ; 18
43e: 91 e0 ldi r25, 0x01 ; 1
440: 0e 94 6c 01 call 0x2d8 ; 0x2d8 <Print::write(char const*) [clone .part.2] [clone .constprop.18]>
size_t Print::println(double num, int digits)
{
size_t n = print(num, digits);
n += println();
return n;
}
444: 8c 0f add r24, r28
446: 9d 1f adc r25, r29
448: df 91 pop r29
44a: cf 91 pop r28
44c: 08 95 ret
0000044e <__vector_16>:
#if defined(TIM0_OVF_vect)
ISR(TIM0_OVF_vect)
#else
ISR(TIMER0_OVF_vect)
#endif
{
44e: 1f 92 push r1
450: 0f 92 push r0
452: 0f b6 in r0, 0x3f ; 63
454: 0f 92 push r0
456: 11 24 eor r1, r1
458: 2f 93 push r18
45a: 3f 93 push r19
45c: 8f 93 push r24
45e: 9f 93 push r25
460: af 93 push r26
462: bf 93 push r27
// copy these to local variables so they can be stored in registers
// (volatile variables must be read from memory on every access)
unsigned long m = timer0_millis;
464: 80 91 1b 01 lds r24, 0x011B ; 0x80011b <timer0_millis>
468: 90 91 1c 01 lds r25, 0x011C ; 0x80011c <timer0_millis+0x1>
46c: a0 91 1d 01 lds r26, 0x011D ; 0x80011d <timer0_millis+0x2>
470: b0 91 1e 01 lds r27, 0x011E ; 0x80011e <timer0_millis+0x3>
unsigned char f = timer0_fract;
474: 30 91 1a 01 lds r19, 0x011A ; 0x80011a <timer0_fract>
m += MILLIS_INC;
f += FRACT_INC;
478: 23 e0 ldi r18, 0x03 ; 3
47a: 23 0f add r18, r19
if (f >= FRACT_MAX) {
47c: 2d 37 cpi r18, 0x7D ; 125
47e: 58 f5 brcc .+86 ; 0x4d6 <__vector_16+0x88>
// copy these to local variables so they can be stored in registers
// (volatile variables must be read from memory on every access)
unsigned long m = timer0_millis;
unsigned char f = timer0_fract;
m += MILLIS_INC;
480: 01 96 adiw r24, 0x01 ; 1
482: a1 1d adc r26, r1
484: b1 1d adc r27, r1
if (f >= FRACT_MAX) {
f -= FRACT_MAX;
m += 1;
}
timer0_fract = f;
486: 20 93 1a 01 sts 0x011A, r18 ; 0x80011a <timer0_fract>
timer0_millis = m;
48a: 80 93 1b 01 sts 0x011B, r24 ; 0x80011b <timer0_millis>
48e: 90 93 1c 01 sts 0x011C, r25 ; 0x80011c <timer0_millis+0x1>
492: a0 93 1d 01 sts 0x011D, r26 ; 0x80011d <timer0_millis+0x2>
496: b0 93 1e 01 sts 0x011E, r27 ; 0x80011e <timer0_millis+0x3>
timer0_overflow_count++;
49a: 80 91 16 01 lds r24, 0x0116 ; 0x800116 <__data_end>
49e: 90 91 17 01 lds r25, 0x0117 ; 0x800117 <__data_end+0x1>
4a2: a0 91 18 01 lds r26, 0x0118 ; 0x800118 <__data_end+0x2>
4a6: b0 91 19 01 lds r27, 0x0119 ; 0x800119 <__data_end+0x3>
4aa: 01 96 adiw r24, 0x01 ; 1
4ac: a1 1d adc r26, r1
4ae: b1 1d adc r27, r1
4b0: 80 93 16 01 sts 0x0116, r24 ; 0x800116 <__data_end>
4b4: 90 93 17 01 sts 0x0117, r25 ; 0x800117 <__data_end+0x1>
4b8: a0 93 18 01 sts 0x0118, r26 ; 0x800118 <__data_end+0x2>
4bc: b0 93 19 01 sts 0x0119, r27 ; 0x800119 <__data_end+0x3>
}
4c0: bf 91 pop r27
4c2: af 91 pop r26
4c4: 9f 91 pop r25
4c6: 8f 91 pop r24
4c8: 3f 91 pop r19
4ca: 2f 91 pop r18
4cc: 0f 90 pop r0
4ce: 0f be out 0x3f, r0 ; 63
4d0: 0f 90 pop r0
4d2: 1f 90 pop r1
4d4: 18 95 reti
unsigned char f = timer0_fract;
m += MILLIS_INC;
f += FRACT_INC;
if (f >= FRACT_MAX) {
f -= FRACT_MAX;
4d6: 26 e8 ldi r18, 0x86 ; 134
4d8: 23 0f add r18, r19
m += 1;
4da: 02 96 adiw r24, 0x02 ; 2
4dc: a1 1d adc r26, r1
4de: b1 1d adc r27, r1
4e0: d2 cf rjmp .-92 ; 0x486 <__vector_16+0x38>
000004e2 <__vector_19>:
#elif defined(USART_UDRE_vect)
ISR(USART_UDRE_vect)
#else
#error "Don't know what the Data Register Empty vector is called for Serial"
#endif
{
4e2: 1f 92 push r1
4e4: 0f 92 push r0
4e6: 0f b6 in r0, 0x3f ; 63
4e8: 0f 92 push r0
4ea: 11 24 eor r1, r1
4ec: 2f 93 push r18
4ee: 3f 93 push r19
4f0: 4f 93 push r20
4f2: 5f 93 push r21
4f4: 6f 93 push r22
4f6: 7f 93 push r23
4f8: 8f 93 push r24
4fa: 9f 93 push r25
4fc: af 93 push r26
4fe: bf 93 push r27
500: ef 93 push r30
502: ff 93 push r31
Serial._tx_udr_empty_irq();
504: 8f e1 ldi r24, 0x1F ; 31
506: 91 e0 ldi r25, 0x01 ; 1
508: 0e 94 dd 00 call 0x1ba ; 0x1ba <HardwareSerial::_tx_udr_empty_irq()>
}
50c: ff 91 pop r31
50e: ef 91 pop r30
510: bf 91 pop r27
512: af 91 pop r26
514: 9f 91 pop r25
516: 8f 91 pop r24
518: 7f 91 pop r23
51a: 6f 91 pop r22
51c: 5f 91 pop r21
51e: 4f 91 pop r20
520: 3f 91 pop r19
522: 2f 91 pop r18
524: 0f 90 pop r0
526: 0f be out 0x3f, r0 ; 63
528: 0f 90 pop r0
52a: 1f 90 pop r1
52c: 18 95 reti
0000052e <__vector_18>:
#elif defined(USART_RXC_vect)
ISR(USART_RXC_vect) // ATmega8
#else
#error "Don't know what the Data Received vector is called for Serial"
#endif
{
52e: 1f 92 push r1
530: 0f 92 push r0
532: 0f b6 in r0, 0x3f ; 63
534: 0f 92 push r0
536: 11 24 eor r1, r1
538: 2f 93 push r18
53a: 8f 93 push r24
53c: 9f 93 push r25
53e: ef 93 push r30
540: ff 93 push r31
// Actual interrupt handlers //////////////////////////////////////////////////////////////
void HardwareSerial::_rx_complete_irq(void)
{
if (bit_is_clear(*_ucsra, UPE0)) {
542: e0 91 2f 01 lds r30, 0x012F ; 0x80012f <Serial+0x10>
546: f0 91 30 01 lds r31, 0x0130 ; 0x800130 <Serial+0x11>
54a: 80 81 ld r24, Z
54c: e0 91 35 01 lds r30, 0x0135 ; 0x800135 <Serial+0x16>
550: f0 91 36 01 lds r31, 0x0136 ; 0x800136 <Serial+0x17>
554: 82 fd sbrc r24, 2
556: 1b c0 rjmp .+54 ; 0x58e <__vector_18+0x60>
// No Parity error, read byte and store it in the buffer if there is
// room
unsigned char c = *_udr;
558: 90 81 ld r25, Z
rx_buffer_index_t i = (unsigned int)(_rx_buffer_head + 1) % SERIAL_RX_BUFFER_SIZE;
55a: 80 91 38 01 lds r24, 0x0138 ; 0x800138 <Serial+0x19>
55e: 8f 5f subi r24, 0xFF ; 255
560: 8f 73 andi r24, 0x3F ; 63
// if we should be storing the received character into the location
// just before the tail (meaning that the head would advance to the
// current location of the tail), we're about to overflow the buffer
// and so we don't write the character or advance the head.
if (i != _rx_buffer_tail) {
562: 20 91 39 01 lds r18, 0x0139 ; 0x800139 <Serial+0x1a>
566: 82 17 cp r24, r18
568: 41 f0 breq .+16 ; 0x57a <__vector_18+0x4c>
_rx_buffer[_rx_buffer_head] = c;
56a: e0 91 38 01 lds r30, 0x0138 ; 0x800138 <Serial+0x19>
56e: f0 e0 ldi r31, 0x00 ; 0
570: e1 5e subi r30, 0xE1 ; 225
572: fe 4f sbci r31, 0xFE ; 254
574: 95 8f std Z+29, r25 ; 0x1d
_rx_buffer_head = i;
576: 80 93 38 01 sts 0x0138, r24 ; 0x800138 <Serial+0x19>
Serial._rx_complete_irq();
}
57a: ff 91 pop r31
57c: ef 91 pop r30
57e: 9f 91 pop r25
580: 8f 91 pop r24
582: 2f 91 pop r18
584: 0f 90 pop r0
586: 0f be out 0x3f, r0 ; 63
588: 0f 90 pop r0
58a: 1f 90 pop r1
58c: 18 95 reti
}
} else {
// Parity error, read byte but discard it
*_udr;
58e: 80 81 ld r24, Z
590: f4 cf rjmp .-24 ; 0x57a <__vector_18+0x4c>
00000592 <main>:
void setupUSB() __attribute__((weak));
void setupUSB() { }
int main(void)
{
592: cf 93 push r28
594: df 93 push r29
596: cd b7 in r28, 0x3d ; 61
598: de b7 in r29, 0x3e ; 62
59a: 2c 97 sbiw r28, 0x0c ; 12
59c: 0f b6 in r0, 0x3f ; 63
59e: f8 94 cli
5a0: de bf out 0x3e, r29 ; 62
5a2: 0f be out 0x3f, r0 ; 63
5a4: cd bf out 0x3d, r28 ; 61
void init()
{
// this needs to be called before setup() or some functions won't
// work there
sei();
5a6: 78 94 sei
// on the ATmega168, timer 0 is also used for fast hardware pwm
// (using phase-correct PWM would mean that timer 0 overflowed half as often
// resulting in different millis() behavior on the ATmega8 and ATmega168)
#if defined(TCCR0A) && defined(WGM01)
sbi(TCCR0A, WGM01);
5a8: 84 b5 in r24, 0x24 ; 36
5aa: 82 60 ori r24, 0x02 ; 2
5ac: 84 bd out 0x24, r24 ; 36
sbi(TCCR0A, WGM00);
5ae: 84 b5 in r24, 0x24 ; 36
5b0: 81 60 ori r24, 0x01 ; 1
5b2: 84 bd out 0x24, r24 ; 36
// this combination is for the standard atmega8
sbi(TCCR0, CS01);
sbi(TCCR0, CS00);
#elif defined(TCCR0B) && defined(CS01) && defined(CS00)
// this combination is for the standard 168/328/1280/2560
sbi(TCCR0B, CS01);
5b4: 85 b5 in r24, 0x25 ; 37
5b6: 82 60 ori r24, 0x02 ; 2
5b8: 85 bd out 0x25, r24 ; 37
sbi(TCCR0B, CS00);
5ba: 85 b5 in r24, 0x25 ; 37
5bc: 81 60 ori r24, 0x01 ; 1
5be: 85 bd out 0x25, r24 ; 37
// enable timer 0 overflow interrupt
#if defined(TIMSK) && defined(TOIE0)
sbi(TIMSK, TOIE0);
#elif defined(TIMSK0) && defined(TOIE0)
sbi(TIMSK0, TOIE0);
5c0: 80 91 6e 00 lds r24, 0x006E ; 0x80006e <__DATA_REGION_ORIGIN__+0xe>
5c4: 81 60 ori r24, 0x01 ; 1
5c6: 80 93 6e 00 sts 0x006E, r24 ; 0x80006e <__DATA_REGION_ORIGIN__+0xe>
// this is better for motors as it ensures an even waveform
// note, however, that fast pwm mode can achieve a frequency of up
// 8 MHz (with a 16 MHz clock) at 50% duty cycle
#if defined(TCCR1B) && defined(CS11) && defined(CS10)
TCCR1B = 0;
5ca: 10 92 81 00 sts 0x0081, r1 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21>
// set timer 1 prescale factor to 64
sbi(TCCR1B, CS11);
5ce: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21>
5d2: 82 60 ori r24, 0x02 ; 2
5d4: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21>
#if F_CPU >= 8000000L
sbi(TCCR1B, CS10);
5d8: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21>
5dc: 81 60 ori r24, 0x01 ; 1
5de: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__DATA_REGION_ORIGIN__+0x21>
sbi(TCCR1, CS10);
#endif
#endif
// put timer 1 in 8-bit phase correct pwm mode
#if defined(TCCR1A) && defined(WGM10)
sbi(TCCR1A, WGM10);
5e2: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__DATA_REGION_ORIGIN__+0x20>
5e6: 81 60 ori r24, 0x01 ; 1
5e8: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__DATA_REGION_ORIGIN__+0x20>
// set timer 2 prescale factor to 64
#if defined(TCCR2) && defined(CS22)
sbi(TCCR2, CS22);
#elif defined(TCCR2B) && defined(CS22)
sbi(TCCR2B, CS22);
5ec: 80 91 b1 00 lds r24, 0x00B1 ; 0x8000b1 <__DATA_REGION_ORIGIN__+0x51>
5f0: 84 60 ori r24, 0x04 ; 4
5f2: 80 93 b1 00 sts 0x00B1, r24 ; 0x8000b1 <__DATA_REGION_ORIGIN__+0x51>
// configure timer 2 for phase correct pwm (8-bit)
#if defined(TCCR2) && defined(WGM20)
sbi(TCCR2, WGM20);
#elif defined(TCCR2A) && defined(WGM20)
sbi(TCCR2A, WGM20);
5f6: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__DATA_REGION_ORIGIN__+0x50>
5fa: 81 60 ori r24, 0x01 ; 1
5fc: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__DATA_REGION_ORIGIN__+0x50>
#endif
#if defined(ADCSRA)
// set a2d prescaler so we are inside the desired 50-200 KHz range.
#if F_CPU >= 16000000 // 16 MHz / 128 = 125 KHz
sbi(ADCSRA, ADPS2);
600: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
604: 84 60 ori r24, 0x04 ; 4
606: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
sbi(ADCSRA, ADPS1);
60a: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
60e: 82 60 ori r24, 0x02 ; 2
610: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
sbi(ADCSRA, ADPS0);
614: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
618: 81 60 ori r24, 0x01 ; 1
61a: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
cbi(ADCSRA, ADPS2);
cbi(ADCSRA, ADPS1);
sbi(ADCSRA, ADPS0);
#endif
// enable a2d conversions
sbi(ADCSRA, ADEN);
61e: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
622: 80 68 ori r24, 0x80 ; 128
624: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__DATA_REGION_ORIGIN__+0x1a>
// here so they can be used as normal digital i/o; they will be
// reconnected in Serial.begin()
#if defined(UCSRB)
UCSRB = 0;
#elif defined(UCSR0B)
UCSR0B = 0;
628: 10 92 c1 00 sts 0x00C1, r1 ; 0x8000c1 <__DATA_REGION_ORIGIN__+0x61>
Serial.println((float) longo_hex);
Serial.println((float) longo_dec);
Serial.println(flutuante_hex);
Serial.println(flutuante_dec);
Serial.println((long) flutuante_hex);
Serial.println((long) flutuante_dec);
62c: 0d b7 in r16, 0x3d ; 61
62e: 1e b7 in r17, 0x3e ; 62
void HardwareSerial::begin(unsigned long baud, byte config)
{
// Try u2x mode first
uint16_t baud_setting = (F_CPU / 4 / baud - 1) / 2;
*_ucsra = 1 << U2X0;
630: e0 91 2f 01 lds r30, 0x012F ; 0x80012f <Serial+0x10>
634: f0 91 30 01 lds r31, 0x0130 ; 0x800130 <Serial+0x11>
638: 82 e0 ldi r24, 0x02 ; 2
63a: 80 83 st Z, r24
*_ucsra = 0;
baud_setting = (F_CPU / 8 / baud - 1) / 2;
}
// assign the baud_setting, a.k.a. ubrr (USART Baud Rate Register)
*_ubrrh = baud_setting >> 8;
63c: e0 91 2b 01 lds r30, 0x012B ; 0x80012b <Serial+0xc>
640: f0 91 2c 01 lds r31, 0x012C ; 0x80012c <Serial+0xd>
644: 10 82 st Z, r1
*_ubrrl = baud_setting;
646: e0 91 2d 01 lds r30, 0x012D ; 0x80012d <Serial+0xe>
64a: f0 91 2e 01 lds r31, 0x012E ; 0x80012e <Serial+0xf>
64e: 8f ec ldi r24, 0xCF ; 207
650: 80 83 st Z, r24
_written = false;
652: 10 92 37 01 sts 0x0137, r1 ; 0x800137 <Serial+0x18>
//set the data bits, parity, and stop bits
#if defined(__AVR_ATmega8__)
config |= 0x80; // select UCSRC register (shared with UBRRH)
#endif
*_ucsrc = config;
656: e0 91 33 01 lds r30, 0x0133 ; 0x800133 <Serial+0x14>
65a: f0 91 34 01 lds r31, 0x0134 ; 0x800134 <Serial+0x15>
65e: 86 e0 ldi r24, 0x06 ; 6
660: 80 83 st Z, r24
sbi(*_ucsrb, RXEN0);
662: e0 91 31 01 lds r30, 0x0131 ; 0x800131 <Serial+0x12>
666: f0 91 32 01 lds r31, 0x0132 ; 0x800132 <Serial+0x13>
66a: 80 81 ld r24, Z
66c: 80 61 ori r24, 0x10 ; 16
66e: 80 83 st Z, r24
sbi(*_ucsrb, TXEN0);
670: e0 91 31 01 lds r30, 0x0131 ; 0x800131 <Serial+0x12>
674: f0 91 32 01 lds r31, 0x0132 ; 0x800132 <Serial+0x13>
678: 80 81 ld r24, Z
67a: 88 60 ori r24, 0x08 ; 8
67c: 80 83 st Z, r24
sbi(*_ucsrb, RXCIE0);
67e: e0 91 31 01 lds r30, 0x0131 ; 0x800131 <Serial+0x12>
682: f0 91 32 01 lds r31, 0x0132 ; 0x800132 <Serial+0x13>
686: 80 81 ld r24, Z
688: 80 68 ori r24, 0x80 ; 128
68a: 80 83 st Z, r24
cbi(*_ucsrb, UDRIE0);
68c: e0 91 31 01 lds r30, 0x0131 ; 0x800131 <Serial+0x12>
690: f0 91 32 01 lds r31, 0x0132 ; 0x800132 <Serial+0x13>
694: 80 81 ld r24, Z
696: 8f 7d andi r24, 0xDF ; 223
698: 80 83 st Z, r24
// put your setup code here, to run once:
int arranjo[5];
int* ponteiro = (int*) 0xF0F0;
ponteiro = arranjo;
Serial.begin(9600);
Serial.println(sizeof(arranjo));
69a: 8a e0 ldi r24, 0x0A ; 10
69c: 90 e0 ldi r25, 0x00 ; 0
69e: 0e 94 eb 01 call 0x3d6 ; 0x3d6 <Print::println(unsigned int, int) [clone .constprop.3]>
Serial.println((long) arranjo);
6a2: ce 01 movw r24, r28
6a4: 01 96 adiw r24, 0x01 ; 1
6a6: 6c 01 movw r12, r24
6a8: 99 0f add r25, r25
6aa: ee 08 sbc r14, r14
6ac: ff 08 sbc r15, r15
6ae: c7 01 movw r24, r14
6b0: b6 01 movw r22, r12
6b2: 0e 94 bd 01 call 0x37a ; 0x37a <Print::println(long, int) [clone .constprop.11]>
Serial.println(sizeof(ponteiro));
6b6: 82 e0 ldi r24, 0x02 ; 2
6b8: 90 e0 ldi r25, 0x00 ; 0
6ba: 0e 94 eb 01 call 0x3d6 ; 0x3d6 <Print::println(unsigned int, int) [clone .constprop.3]>
Serial.println((long) ponteiro);
6be: c7 01 movw r24, r14
6c0: b6 01 movw r22, r12
6c2: 0e 94 bd 01 call 0x37a ; 0x37a <Print::println(long, int) [clone .constprop.11]>
int a;
ponteiro = &a;
Serial.println(sizeof(ponteiro));
6c6: 82 e0 ldi r24, 0x02 ; 2
6c8: 90 e0 ldi r25, 0x00 ; 0
6ca: 0e 94 eb 01 call 0x3d6 ; 0x3d6 <Print::println(unsigned int, int) [clone .constprop.3]>
Serial.println((long) ponteiro);
6ce: be 01 movw r22, r28
6d0: 65 5f subi r22, 0xF5 ; 245
6d2: 7f 4f sbci r23, 0xFF ; 255
6d4: 07 2e mov r0, r23
6d6: 00 0c add r0, r0
6d8: 88 0b sbc r24, r24
6da: 99 0b sbc r25, r25
6dc: 0e 94 bd 01 call 0x37a ; 0x37a <Print::println(long, int) [clone .constprop.11]>
while(!Serial.available());
6e0: 8f e1 ldi r24, 0x1F ; 31
6e2: 91 e0 ldi r25, 0x01 ; 1
6e4: 0e 94 bd 00 call 0x17a ; 0x17a <HardwareSerial::available()>
6e8: 89 2b or r24, r25
6ea: d1 f3 breq .-12 ; 0x6e0 <main+0x14e>
a = (int) Serial.read();
6ec: 8f e1 ldi r24, 0x1F ; 31
6ee: 91 e0 ldi r25, 0x01 ; 1
6f0: 0e 94 9b 00 call 0x136 ; 0x136 <HardwareSerial::read()>
6f4: 9c 87 std Y+12, r25 ; 0x0c
6f6: 8b 87 std Y+11, r24 ; 0x0b
int novo_arranjo[a];
6f8: 88 0f add r24, r24
6fa: 99 1f adc r25, r25
6fc: 2d b7 in r18, 0x3d ; 61
6fe: 3e b7 in r19, 0x3e ; 62
700: 28 1b sub r18, r24
702: 39 0b sbc r19, r25
704: 0f b6 in r0, 0x3f ; 63
706: f8 94 cli
708: 3e bf out 0x3e, r19 ; 62
70a: 0f be out 0x3f, r0 ; 63
70c: 2d bf out 0x3d, r18 ; 61
70e: 2f 5f subi r18, 0xFF ; 255
710: 3f 4f sbci r19, 0xFF ; 255
712: 79 01 movw r14, r18
Serial.println(sizeof(novo_arranjo));
714: 0e 94 eb 01 call 0x3d6 ; 0x3d6 <Print::println(unsigned int, int) [clone .constprop.3]>
Serial.println((long) novo_arranjo);
718: b7 01 movw r22, r14
71a: ff 0c add r15, r15
71c: 88 0b sbc r24, r24
71e: 99 0b sbc r25, r25
720: 0e 94 bd 01 call 0x37a ; 0x37a <Print::println(long, int) [clone .constprop.11]>
724: 82 e1 ldi r24, 0x12 ; 18
726: 91 e0 ldi r25, 0x01 ; 1
728: 0e 94 6c 01 call 0x2d8 ; 0x2d8 <Print::write(char const*) [clone .part.2] [clone .constprop.18]>
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
72c: 4a e0 ldi r20, 0x0A ; 10
72e: 6f ef ldi r22, 0xFF ; 255
730: 7f ef ldi r23, 0xFF ; 255
732: 8f ef ldi r24, 0xFF ; 255
734: 9f e0 ldi r25, 0x0F ; 15
736: 0e 94 79 01 call 0x2f2 ; 0x2f2 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.15]>
73a: 82 e1 ldi r24, 0x12 ; 18
73c: 91 e0 ldi r25, 0x01 ; 1
73e: 0e 94 6c 01 call 0x2d8 ; 0x2d8 <Print::write(char const*) [clone .part.2] [clone .constprop.18]>
742: 4a e0 ldi r20, 0x0A ; 10
744: 6f ef ldi r22, 0xFF ; 255
746: 7f ef ldi r23, 0xFF ; 255
748: 8f ef ldi r24, 0xFF ; 255
74a: 9f e0 ldi r25, 0x0F ; 15
74c: 0e 94 79 01 call 0x2f2 ; 0x2f2 <Print::printNumber(unsigned long, unsigned char) [clone .constprop.15]>
750: 82 e1 ldi r24, 0x12 ; 18
752: 91 e0 ldi r25, 0x01 ; 1
754: 0e 94 6c 01 call 0x2d8 ; 0x2d8 <Print::write(char const*) [clone .part.2] [clone .constprop.18]>
float flutuante_hex = 0x0FFFFFFF;
float flutuante_dec = 268435455;
Serial.println();
Serial.println(longo_hex);
Serial.println(longo_dec);
Serial.println((float) longo_hex);
758: 0e 94 fd 01 call 0x3fa ; 0x3fa <Print::println(double, int) [clone .constprop.5]>
Serial.println((float) longo_dec);
75c: 0e 94 fd 01 call 0x3fa ; 0x3fa <Print::println(double, int) [clone .constprop.5]>
Serial.println(flutuante_hex);
760: 0e 94 fd 01 call 0x3fa ; 0x3fa <Print::println(double, int) [clone .constprop.5]>
Serial.println(flutuante_dec);
764: 0e 94 fd 01 call 0x3fa ; 0x3fa <Print::println(double, int) [clone .constprop.5]>
Serial.println((long) flutuante_hex);
768: 60 e0 ldi r22, 0x00 ; 0
76a: 70 e0 ldi r23, 0x00 ; 0
76c: 80 e0 ldi r24, 0x00 ; 0
76e: 90 e1 ldi r25, 0x10 ; 16
770: 0e 94 bd 01 call 0x37a ; 0x37a <Print::println(long, int) [clone .constprop.11]>
Serial.println((long) flutuante_dec);
774: 60 e0 ldi r22, 0x00 ; 0
776: 70 e0 ldi r23, 0x00 ; 0
778: 80 e0 ldi r24, 0x00 ; 0
77a: 90 e1 ldi r25, 0x10 ; 16
77c: 0e 94 bd 01 call 0x37a ; 0x37a <Print::println(long, int) [clone .constprop.11]>
780: 0f b6 in r0, 0x3f ; 63
782: f8 94 cli
784: 1e bf out 0x3e, r17 ; 62
786: 0f be out 0x3f, r0 ; 63
788: 0d bf out 0x3d, r16 ; 61
#endif
void serialEventRun(void)
{
#if defined(HAVE_HWSERIAL0)
if (Serial0_available && serialEvent && Serial0_available()) serialEvent();
78a: 00 e0 ldi r16, 0x00 ; 0
78c: 10 e0 ldi r17, 0x00 ; 0
78e: 01 15 cp r16, r1
790: 11 05 cpc r17, r1
792: e9 f3 breq .-6 ; 0x78e <main+0x1fc>
794: 0e 94 c9 00 call 0x192 ; 0x192 <Serial0_available()>
798: 88 23 and r24, r24
79a: c9 f3 breq .-14 ; 0x78e <main+0x1fc>
79c: 0e 94 00 00 call 0 ; 0x0 <__vectors>
7a0: f6 cf rjmp .-20 ; 0x78e <main+0x1fc>
000007a2 <_GLOBAL__sub_I___vector_18>:
size_t printNumber(unsigned long, uint8_t);
size_t printFloat(double, uint8_t);
protected:
void setWriteError(int err = 1) { write_error = err; }
public:
Print() : write_error(0) {}
7a2: ef e1 ldi r30, 0x1F ; 31
7a4: f1 e0 ldi r31, 0x01 ; 1
7a6: 13 82 std Z+3, r1 ; 0x03
7a8: 12 82 std Z+2, r1 ; 0x02
public:
virtual int available() = 0;
virtual int read() = 0;
virtual int peek() = 0;
Stream() {_timeout=1000;}
7aa: 88 ee ldi r24, 0xE8 ; 232
7ac: 93 e0 ldi r25, 0x03 ; 3
7ae: a0 e0 ldi r26, 0x00 ; 0
7b0: b0 e0 ldi r27, 0x00 ; 0
7b2: 84 83 std Z+4, r24 ; 0x04
7b4: 95 83 std Z+5, r25 ; 0x05
7b6: a6 83 std Z+6, r26 ; 0x06
7b8: b7 83 std Z+7, r27 ; 0x07
volatile uint8_t *ucsrc, volatile uint8_t *udr) :
_ubrrh(ubrrh), _ubrrl(ubrrl),
_ucsra(ucsra), _ucsrb(ucsrb), _ucsrc(ucsrc),
_udr(udr),
_rx_buffer_head(0), _rx_buffer_tail(0),
_tx_buffer_head(0), _tx_buffer_tail(0)
7ba: 84 e0 ldi r24, 0x04 ; 4
7bc: 91 e0 ldi r25, 0x01 ; 1
7be: 91 83 std Z+1, r25 ; 0x01
7c0: 80 83 st Z, r24
7c2: 85 ec ldi r24, 0xC5 ; 197
7c4: 90 e0 ldi r25, 0x00 ; 0
7c6: 95 87 std Z+13, r25 ; 0x0d
7c8: 84 87 std Z+12, r24 ; 0x0c
7ca: 84 ec ldi r24, 0xC4 ; 196
7cc: 90 e0 ldi r25, 0x00 ; 0
7ce: 97 87 std Z+15, r25 ; 0x0f
7d0: 86 87 std Z+14, r24 ; 0x0e
7d2: 80 ec ldi r24, 0xC0 ; 192
7d4: 90 e0 ldi r25, 0x00 ; 0
7d6: 91 8b std Z+17, r25 ; 0x11
7d8: 80 8b std Z+16, r24 ; 0x10
7da: 81 ec ldi r24, 0xC1 ; 193
7dc: 90 e0 ldi r25, 0x00 ; 0
7de: 93 8b std Z+19, r25 ; 0x13
7e0: 82 8b std Z+18, r24 ; 0x12
7e2: 82 ec ldi r24, 0xC2 ; 194
7e4: 90 e0 ldi r25, 0x00 ; 0
7e6: 95 8b std Z+21, r25 ; 0x15
7e8: 84 8b std Z+20, r24 ; 0x14
7ea: 86 ec ldi r24, 0xC6 ; 198
7ec: 90 e0 ldi r25, 0x00 ; 0
7ee: 97 8b std Z+23, r25 ; 0x17
7f0: 86 8b std Z+22, r24 ; 0x16
7f2: 11 8e std Z+25, r1 ; 0x19
7f4: 12 8e std Z+26, r1 ; 0x1a
7f6: 13 8e std Z+27, r1 ; 0x1b
7f8: 14 8e std Z+28, r1 ; 0x1c
// Function that can be weakly referenced by serialEventRun to prevent
// pulling in this file if it's not otherwise used.
bool Serial0_available() {
return Serial.available();
}
7fa: 08 95 ret
000007fc <__udivmodsi4>:
7fc: a1 e2 ldi r26, 0x21 ; 33
7fe: 1a 2e mov r1, r26
800: aa 1b sub r26, r26
802: bb 1b sub r27, r27
804: fd 01 movw r30, r26
806: 0d c0 rjmp .+26 ; 0x822 <__udivmodsi4_ep>
00000808 <__udivmodsi4_loop>:
808: aa 1f adc r26, r26
80a: bb 1f adc r27, r27
80c: ee 1f adc r30, r30
80e: ff 1f adc r31, r31
810: a2 17 cp r26, r18
812: b3 07 cpc r27, r19
814: e4 07 cpc r30, r20
816: f5 07 cpc r31, r21
818: 20 f0 brcs .+8 ; 0x822 <__udivmodsi4_ep>
81a: a2 1b sub r26, r18
81c: b3 0b sbc r27, r19
81e: e4 0b sbc r30, r20
820: f5 0b sbc r31, r21
00000822 <__udivmodsi4_ep>:
822: 66 1f adc r22, r22
824: 77 1f adc r23, r23
826: 88 1f adc r24, r24
828: 99 1f adc r25, r25
82a: 1a 94 dec r1
82c: 69 f7 brne .-38 ; 0x808 <__udivmodsi4_loop>
82e: 60 95 com r22
830: 70 95 com r23
832: 80 95 com r24
834: 90 95 com r25
836: 9b 01 movw r18, r22
838: ac 01 movw r20, r24
83a: bd 01 movw r22, r26
83c: cf 01 movw r24, r30
83e: 08 95 ret
00000840 <__tablejump2__>:
840: ee 0f add r30, r30
842: ff 1f adc r31, r31
844: 05 90 lpm r0, Z+
846: f4 91 lpm r31, Z
848: e0 2d mov r30, r0
84a: 09 94 ijmp
0000084c <_exit>:
84c: f8 94 cli
0000084e <__stop_program>:
84e: ff cf rjmp .-2 ; 0x84e <__stop_program>
Thank you!!!