/tmp/arduino_build_507726/timer_poll_compare_flag.ino.ino.elf: file format elf32-avr Disassembly of section .text: 00000000 <__vectors>: 0: 0c 94 61 00 jmp 0xc2 ; 0xc2 <__ctors_end> 4: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 8: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> c: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 10: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 14: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 18: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 1c: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 20: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 24: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 28: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 2c: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 30: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 34: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 38: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 3c: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 40: 0c 94 bd 00 jmp 0x17a ; 0x17a <__vector_16> 44: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 48: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 4c: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 50: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 54: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 58: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 5c: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 60: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 64: 0c 94 73 00 jmp 0xe6 ; 0xe6 <__bad_interrupt> 00000068 <__trampolines_end>: 68: 00 00 nop 6a: 00 00 nop 6c: 23 00 .word 0x0023 ; ???? 6e: 26 00 .word 0x0026 ; ???? 70: 29 00 .word 0x0029 ; ???? 00000072 : 72: 00 00 00 08 00 02 01 00 00 03 04 07 00 00 00 00 ................ 82: 00 00 00 00 .... 00000086 : 86: 00 00 00 00 25 00 28 00 2b 00 ....%.(.+. 00000090 : 90: 00 00 00 00 24 00 27 00 2a 00 ....$.'.*. 0000009a : 9a: 04 04 04 04 04 04 04 04 02 02 02 02 02 02 03 03 ................ aa: 03 03 03 03 .... 000000ae : ae: 01 02 04 08 10 20 40 80 01 02 04 08 10 20 01 02 ..... @...... .. be: 04 08 10 20 ... 000000c2 <__ctors_end>: c2: 11 24 eor r1, r1 c4: 1f be out 0x3f, r1 ; 63 c6: cf ef ldi r28, 0xFF ; 255 c8: d8 e0 ldi r29, 0x08 ; 8 ca: de bf out 0x3e, r29 ; 62 cc: cd bf out 0x3d, r28 ; 61 000000ce <__do_clear_bss>: ce: 21 e0 ldi r18, 0x01 ; 1 d0: a0 e0 ldi r26, 0x00 ; 0 d2: b1 e0 ldi r27, 0x01 ; 1 d4: 01 c0 rjmp .+2 ; 0xd8 <.do_clear_bss_start> 000000d6 <.do_clear_bss_loop>: d6: 1d 92 st X+, r1 000000d8 <.do_clear_bss_start>: d8: a9 30 cpi r26, 0x09 ; 9 da: b2 07 cpc r27, r18 dc: e1 f7 brne .-8 ; 0xd6 <.do_clear_bss_loop> de: 0e 94 07 01 call 0x20e ; 0x20e
e2: 0c 94 ae 01 jmp 0x35c ; 0x35c <_exit> 000000e6 <__bad_interrupt>: e6: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> 000000ea : #include "wiring_private.h" #include "pins_arduino.h" void pinMode(uint8_t pin, uint8_t mode) { uint8_t bit = digitalPinToBitMask(pin); ea: 90 e0 ldi r25, 0x00 ; 0 ec: fc 01 movw r30, r24 ee: e2 55 subi r30, 0x52 ; 82 f0: ff 4f sbci r31, 0xFF ; 255 f2: 24 91 lpm r18, Z uint8_t port = digitalPinToPort(pin); f4: fc 01 movw r30, r24 f6: e6 56 subi r30, 0x66 ; 102 f8: ff 4f sbci r31, 0xFF ; 255 fa: 84 91 lpm r24, Z volatile uint8_t *reg, *out; if (port == NOT_A_PIN) return; fc: 88 23 and r24, r24 fe: 99 f0 breq .+38 ; 0x126 // JWS: can I let the optimizer do this? reg = portModeRegister(port); 100: 90 e0 ldi r25, 0x00 ; 0 102: 88 0f add r24, r24 104: 99 1f adc r25, r25 106: fc 01 movw r30, r24 108: e0 57 subi r30, 0x70 ; 112 10a: ff 4f sbci r31, 0xFF ; 255 10c: a5 91 lpm r26, Z+ 10e: b4 91 lpm r27, Z out = portOutputRegister(port); 110: fc 01 movw r30, r24 112: ea 57 subi r30, 0x7A ; 122 114: ff 4f sbci r31, 0xFF ; 255 116: 85 91 lpm r24, Z+ 118: 94 91 lpm r25, Z cli(); *reg &= ~bit; *out |= bit; SREG = oldSREG; } else { uint8_t oldSREG = SREG; 11a: 8f b7 in r24, 0x3f ; 63 cli(); 11c: f8 94 cli *reg |= bit; 11e: ec 91 ld r30, X 120: e2 2b or r30, r18 122: ec 93 st X, r30 SREG = oldSREG; 124: 8f bf out 0x3f, r24 ; 63 126: 08 95 ret 00000128 : // //static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline)); //static inline void turnOffPWM(uint8_t timer) static void turnOffPWM(uint8_t timer) { switch (timer) 128: 83 30 cpi r24, 0x03 ; 3 12a: 81 f0 breq .+32 ; 0x14c 12c: 28 f4 brcc .+10 ; 0x138 12e: 81 30 cpi r24, 0x01 ; 1 130: 99 f0 breq .+38 ; 0x158 132: 82 30 cpi r24, 0x02 ; 2 134: a1 f0 breq .+40 ; 0x15e 136: 08 95 ret 138: 87 30 cpi r24, 0x07 ; 7 13a: a9 f0 breq .+42 ; 0x166 13c: 88 30 cpi r24, 0x08 ; 8 13e: b9 f0 breq .+46 ; 0x16e 140: 84 30 cpi r24, 0x04 ; 4 142: d1 f4 brne .+52 ; 0x178 { #if defined(TCCR1A) && defined(COM1A1) case TIMER1A: cbi(TCCR1A, COM1A1); break; #endif #if defined(TCCR1A) && defined(COM1B1) case TIMER1B: cbi(TCCR1A, COM1B1); break; 144: 80 91 80 00 lds r24, 0x0080 148: 8f 7d andi r24, 0xDF ; 223 14a: 03 c0 rjmp .+6 ; 0x152 static void turnOffPWM(uint8_t timer) { switch (timer) { #if defined(TCCR1A) && defined(COM1A1) case TIMER1A: cbi(TCCR1A, COM1A1); break; 14c: 80 91 80 00 lds r24, 0x0080 150: 8f 77 andi r24, 0x7F ; 127 #endif #if defined(TCCR1A) && defined(COM1B1) case TIMER1B: cbi(TCCR1A, COM1B1); break; 152: 80 93 80 00 sts 0x0080, r24 156: 08 95 ret #if defined(TCCR2) && defined(COM21) case TIMER2: cbi(TCCR2, COM21); break; #endif #if defined(TCCR0A) && defined(COM0A1) case TIMER0A: cbi(TCCR0A, COM0A1); break; 158: 84 b5 in r24, 0x24 ; 36 15a: 8f 77 andi r24, 0x7F ; 127 15c: 02 c0 rjmp .+4 ; 0x162 #endif #if defined(TCCR0A) && defined(COM0B1) case TIMER0B: cbi(TCCR0A, COM0B1); break; 15e: 84 b5 in r24, 0x24 ; 36 160: 8f 7d andi r24, 0xDF ; 223 162: 84 bd out 0x24, r24 ; 36 164: 08 95 ret #endif #if defined(TCCR2A) && defined(COM2A1) case TIMER2A: cbi(TCCR2A, COM2A1); break; 166: 80 91 b0 00 lds r24, 0x00B0 16a: 8f 77 andi r24, 0x7F ; 127 16c: 03 c0 rjmp .+6 ; 0x174 #endif #if defined(TCCR2A) && defined(COM2B1) case TIMER2B: cbi(TCCR2A, COM2B1); break; 16e: 80 91 b0 00 lds r24, 0x00B0 172: 8f 7d andi r24, 0xDF ; 223 174: 80 93 b0 00 sts 0x00B0, r24 178: 08 95 ret 0000017a <__vector_16>: #if defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__) ISR(TIM0_OVF_vect) #else ISR(TIMER0_OVF_vect) #endif { 17a: 1f 92 push r1 17c: 0f 92 push r0 17e: 0f b6 in r0, 0x3f ; 63 180: 0f 92 push r0 182: 11 24 eor r1, r1 184: 2f 93 push r18 186: 3f 93 push r19 188: 8f 93 push r24 18a: 9f 93 push r25 18c: af 93 push r26 18e: 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; 190: 80 91 05 01 lds r24, 0x0105 194: 90 91 06 01 lds r25, 0x0106 198: a0 91 07 01 lds r26, 0x0107 19c: b0 91 08 01 lds r27, 0x0108 unsigned char f = timer0_fract; 1a0: 30 91 04 01 lds r19, 0x0104 m += MILLIS_INC; f += FRACT_INC; 1a4: 23 e0 ldi r18, 0x03 ; 3 1a6: 23 0f add r18, r19 if (f >= FRACT_MAX) { 1a8: 2d 37 cpi r18, 0x7D ; 125 1aa: 20 f4 brcc .+8 ; 0x1b4 <__vector_16+0x3a> // 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; 1ac: 01 96 adiw r24, 0x01 ; 1 1ae: a1 1d adc r26, r1 1b0: b1 1d adc r27, r1 1b2: 05 c0 rjmp .+10 ; 0x1be <__vector_16+0x44> f += FRACT_INC; if (f >= FRACT_MAX) { f -= FRACT_MAX; 1b4: 26 e8 ldi r18, 0x86 ; 134 1b6: 23 0f add r18, r19 m += 1; 1b8: 02 96 adiw r24, 0x02 ; 2 1ba: a1 1d adc r26, r1 1bc: b1 1d adc r27, r1 } timer0_fract = f; 1be: 20 93 04 01 sts 0x0104, r18 timer0_millis = m; 1c2: 80 93 05 01 sts 0x0105, r24 1c6: 90 93 06 01 sts 0x0106, r25 1ca: a0 93 07 01 sts 0x0107, r26 1ce: b0 93 08 01 sts 0x0108, r27 timer0_overflow_count++; 1d2: 80 91 00 01 lds r24, 0x0100 1d6: 90 91 01 01 lds r25, 0x0101 1da: a0 91 02 01 lds r26, 0x0102 1de: b0 91 03 01 lds r27, 0x0103 1e2: 01 96 adiw r24, 0x01 ; 1 1e4: a1 1d adc r26, r1 1e6: b1 1d adc r27, r1 1e8: 80 93 00 01 sts 0x0100, r24 1ec: 90 93 01 01 sts 0x0101, r25 1f0: a0 93 02 01 sts 0x0102, r26 1f4: b0 93 03 01 sts 0x0103, r27 } 1f8: bf 91 pop r27 1fa: af 91 pop r26 1fc: 9f 91 pop r25 1fe: 8f 91 pop r24 200: 3f 91 pop r19 202: 2f 91 pop r18 204: 0f 90 pop r0 206: 0f be out 0x3f, r0 ; 63 208: 0f 90 pop r0 20a: 1f 90 pop r1 20c: 18 95 reti 0000020e
: void init() { // this needs to be called before setup() or some functions won't // work there sei(); 20e: 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); 210: 84 b5 in r24, 0x24 ; 36 212: 82 60 ori r24, 0x02 ; 2 214: 84 bd out 0x24, r24 ; 36 sbi(TCCR0A, WGM00); 216: 84 b5 in r24, 0x24 ; 36 218: 81 60 ori r24, 0x01 ; 1 21a: 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); 21c: 85 b5 in r24, 0x25 ; 37 21e: 82 60 ori r24, 0x02 ; 2 220: 85 bd out 0x25, r24 ; 37 sbi(TCCR0B, CS00); 222: 85 b5 in r24, 0x25 ; 37 224: 81 60 ori r24, 0x01 ; 1 226: 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); 228: 80 91 6e 00 lds r24, 0x006E 22c: 81 60 ori r24, 0x01 ; 1 22e: 80 93 6e 00 sts 0x006E, r24 // 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; 232: 10 92 81 00 sts 0x0081, r1 // set timer 1 prescale factor to 64 sbi(TCCR1B, CS11); 236: 80 91 81 00 lds r24, 0x0081 23a: 82 60 ori r24, 0x02 ; 2 23c: 80 93 81 00 sts 0x0081, r24 #if F_CPU >= 8000000L sbi(TCCR1B, CS10); 240: 80 91 81 00 lds r24, 0x0081 244: 81 60 ori r24, 0x01 ; 1 246: 80 93 81 00 sts 0x0081, r24 sbi(TCCR1, CS10); #endif #endif // put timer 1 in 8-bit phase correct pwm mode #if defined(TCCR1A) && defined(WGM10) sbi(TCCR1A, WGM10); 24a: 80 91 80 00 lds r24, 0x0080 24e: 81 60 ori r24, 0x01 ; 1 250: 80 93 80 00 sts 0x0080, r24 // set timer 2 prescale factor to 64 #if defined(TCCR2) && defined(CS22) sbi(TCCR2, CS22); #elif defined(TCCR2B) && defined(CS22) sbi(TCCR2B, CS22); 254: 80 91 b1 00 lds r24, 0x00B1 258: 84 60 ori r24, 0x04 ; 4 25a: 80 93 b1 00 sts 0x00B1, r24 // 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); 25e: 80 91 b0 00 lds r24, 0x00B0 262: 81 60 ori r24, 0x01 ; 1 264: 80 93 b0 00 sts 0x00B0, r24 #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); 268: 80 91 7a 00 lds r24, 0x007A 26c: 84 60 ori r24, 0x04 ; 4 26e: 80 93 7a 00 sts 0x007A, r24 sbi(ADCSRA, ADPS1); 272: 80 91 7a 00 lds r24, 0x007A 276: 82 60 ori r24, 0x02 ; 2 278: 80 93 7a 00 sts 0x007A, r24 sbi(ADCSRA, ADPS0); 27c: 80 91 7a 00 lds r24, 0x007A 280: 81 60 ori r24, 0x01 ; 1 282: 80 93 7a 00 sts 0x007A, r24 cbi(ADCSRA, ADPS2); cbi(ADCSRA, ADPS1); sbi(ADCSRA, ADPS0); #endif // enable a2d conversions sbi(ADCSRA, ADEN); 286: 80 91 7a 00 lds r24, 0x007A 28a: 80 68 ori r24, 0x80 ; 128 28c: 80 93 7a 00 sts 0x007A, r24 // 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; 290: 10 92 c1 00 sts 0x00C1, r1 const byte CLOCKOUT = 9; // Uno, Duemilanove, etc. //OC1A is PB1/UNO 9 //OC1B is PB2/UNO 10 void setup () { pinMode (LED_PIN, OUTPUT); 294: 8d e0 ldi r24, 0x0D ; 13 296: 0e 94 75 00 call 0xea ; 0xea // set up 8 MHz timer on CLOCKOUT (OC1A) pinMode (CLOCKOUT, OUTPUT); 29a: 89 e0 ldi r24, 0x09 ; 9 29c: 0e 94 75 00 call 0xea ; 0xea // set up Timer 1 TCCR1A = 0b00000000; 2a0: 10 92 80 00 sts 0x0080, r1 TCCR1B = bit (WGM12) | bit (CS12) | bit (CS10); // CTC, clk/1024 2a4: 8d e0 ldi r24, 0x0D ; 13 2a6: 80 93 81 00 sts 0x0081, r24 OCR1A = 65535; // output every 65536th cycle 2aa: 8f ef ldi r24, 0xFF ; 255 2ac: 9f ef ldi r25, 0xFF ; 255 2ae: 90 93 89 00 sts 0x0089, r25 2b2: 80 93 88 00 sts 0x0088, r24 SREG = oldSREG; } int digitalRead(uint8_t pin) { uint8_t timer = digitalPinToTimer(pin); 2b6: cf e7 ldi r28, 0x7F ; 127 2b8: d0 e0 ldi r29, 0x00 ; 0 uint8_t bit = digitalPinToBitMask(pin); 2ba: 0b eb ldi r16, 0xBB ; 187 2bc: 10 e0 ldi r17, 0x00 ; 0 uint8_t port = digitalPinToPort(pin); 2be: 47 ea ldi r20, 0xA7 ; 167 2c0: e4 2e mov r14, r20 2c2: 40 e0 ldi r20, 0x00 ; 0 2c4: f4 2e mov r15, r20 setup(); for (;;) { loop(); if (serialEventRun) serialEventRun(); 2c6: 50 e0 ldi r21, 0x00 ; 0 2c8: c5 2e mov r12, r21 2ca: 50 e0 ldi r21, 0x00 ; 0 2cc: d5 2e mov r13, r21 } // end of setup void loop () { if ((TIFR1 & (1 << OCF1A)) == 0) { 2ce: b1 9b sbis 0x16, 1 ; 22 2d0: 3e c0 rjmp .+124 ; 0x34e SREG = oldSREG; } int digitalRead(uint8_t pin) { uint8_t timer = digitalPinToTimer(pin); 2d2: fe 01 movw r30, r28 2d4: 84 91 lpm r24, Z uint8_t bit = digitalPinToBitMask(pin); 2d6: f8 01 movw r30, r16 2d8: a4 90 lpm r10, Z uint8_t port = digitalPinToPort(pin); 2da: f7 01 movw r30, r14 2dc: b4 90 lpm r11, Z if (port == NOT_A_PIN) return LOW; 2de: bb 20 and r11, r11 2e0: a1 f0 breq .+40 ; 0x30a // If the pin that support PWM output, we need to turn it off // before getting a digital reading. if (timer != NOT_ON_TIMER) turnOffPWM(timer); 2e2: 81 11 cpse r24, r1 2e4: 0e 94 94 00 call 0x128 ; 0x128 if (*portInputRegister(port) & bit) return HIGH; 2e8: eb 2d mov r30, r11 2ea: f0 e0 ldi r31, 0x00 ; 0 2ec: ee 0f add r30, r30 2ee: ff 1f adc r31, r31 2f0: e8 59 subi r30, 0x98 ; 152 2f2: ff 4f sbci r31, 0xFF ; 255 2f4: a5 91 lpm r26, Z+ 2f6: b4 91 lpm r27, Z 2f8: 8c 91 ld r24, X 2fa: a8 22 and r10, r24 2fc: 91 e0 ldi r25, 0x01 ; 1 2fe: 80 e0 ldi r24, 0x00 ; 0 300: 09 f4 brne .+2 ; 0x304 302: 90 e0 ldi r25, 0x00 ; 0 { uint8_t timer = digitalPinToTimer(pin); uint8_t bit = digitalPinToBitMask(pin); uint8_t port = digitalPinToPort(pin); if (port == NOT_A_PIN) return LOW; 304: a9 2e mov r10, r25 306: b8 2e mov r11, r24 308: 02 c0 rjmp .+4 ; 0x30e 30a: a1 2c mov r10, r1 30c: b1 2c mov r11, r1 } } void digitalWrite(uint8_t pin, uint8_t val) { uint8_t timer = digitalPinToTimer(pin); 30e: fe 01 movw r30, r28 310: 84 91 lpm r24, Z uint8_t bit = digitalPinToBitMask(pin); 312: f8 01 movw r30, r16 314: 84 90 lpm r8, Z uint8_t port = digitalPinToPort(pin); 316: f7 01 movw r30, r14 318: 94 90 lpm r9, Z volatile uint8_t *out; if (port == NOT_A_PIN) return; 31a: 99 20 and r9, r9 31c: b9 f0 breq .+46 ; 0x34c // If the pin that support PWM output, we need to turn it off // before doing a digital write. if (timer != NOT_ON_TIMER) turnOffPWM(timer); 31e: 81 11 cpse r24, r1 320: 0e 94 94 00 call 0x128 ; 0x128 out = portOutputRegister(port); 324: 89 2d mov r24, r9 326: 90 e0 ldi r25, 0x00 ; 0 328: 88 0f add r24, r24 32a: 99 1f adc r25, r25 32c: 8a 57 subi r24, 0x7A ; 122 32e: 9f 4f sbci r25, 0xFF ; 255 330: fc 01 movw r30, r24 332: a5 91 lpm r26, Z+ 334: b4 91 lpm r27, Z uint8_t oldSREG = SREG; 336: 8f b7 in r24, 0x3f ; 63 cli(); 338: f8 94 cli if (val == LOW) { *out &= ~bit; 33a: 9c 91 ld r25, X out = portOutputRegister(port); uint8_t oldSREG = SREG; cli(); if (val == LOW) { 33c: ab 28 or r10, r11 33e: 19 f0 breq .+6 ; 0x346 *out &= ~bit; 340: 80 94 com r8 342: 89 22 and r8, r25 344: 01 c0 rjmp .+2 ; 0x348 } else { *out |= bit; 346: 89 2a or r8, r25 348: 8c 92 st X, r8 } SREG = oldSREG; 34a: 8f bf out 0x3f, r24 ; 63 return; //The flag is not set, so return } else { digitalWrite(LED_PIN,!digitalRead(LED_PIN)); TIFR1 |= 1 << OCF1A ; //clear match bit 34c: b1 9a sbi 0x16, 1 ; 22 34e: c1 14 cp r12, r1 350: d1 04 cpc r13, r1 352: 09 f4 brne .+2 ; 0x356 354: bc cf rjmp .-136 ; 0x2ce 356: 0e 94 00 00 call 0 ; 0x0 <__vectors> 35a: b9 cf rjmp .-142 ; 0x2ce 0000035c <_exit>: 35c: f8 94 cli 0000035e <__stop_program>: 35e: ff cf rjmp .-2 ; 0x35e <__stop_program>