gokul/acoustic-guitar-tuner
This code defines the physical pin configuration and footprint layouts for the ATtiny1616 microcontroller and a matching tactile switch component, including their key hardware connection points, dimensions, and 3D models.
- Version
- 1.0.10
- License
- unset
- Stars
- 1
firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino.t1616.10c0.mD0.v2611.lst
/Users/gokul/Library/Caches/arduino/sketches/8973098C7AF9C42C1264BF017CDD1C0B/acoustic_tuner_attiny1616.ino.elf: file format elf32-avr
Disassembly of section .text:
00000000 <__vectors>:
__vectors():
../../../../crt1/gcrt1.S:61
0: 6a c0 rjmp .+212 ; 0xd6 <__ctors_end>
2: 00 00 nop
../../../../crt1/gcrt1.S:67
4: 84 c0 rjmp .+264 ; 0x10e <__bad_interrupt>
6: 00 00 nop
../../../../crt1/gcrt1.S:68
8: 82 c0 rjmp .+260 ; 0x10e <__bad_interrupt>
a: 00 00 nop
../../../../crt1/gcrt1.S:69
c: 80 c0 rjmp .+256 ; 0x10e <__bad_interrupt>
e: 00 00 nop
../../../../crt1/gcrt1.S:70
10: 7e c0 rjmp .+252 ; 0x10e <__bad_interrupt>
12: 00 00 nop
../../../../crt1/gcrt1.S:71
14: 7c c0 rjmp .+248 ; 0x10e <__bad_interrupt>
16: 00 00 nop
../../../../crt1/gcrt1.S:72
18: 7a c0 rjmp .+244 ; 0x10e <__bad_interrupt>
1a: 00 00 nop
../../../../crt1/gcrt1.S:73
1c: 78 c0 rjmp .+240 ; 0x10e <__bad_interrupt>
1e: 00 00 nop
../../../../crt1/gcrt1.S:74
20: 76 c0 rjmp .+236 ; 0x10e <__bad_interrupt>
22: 00 00 nop
../../../../crt1/gcrt1.S:75
24: 74 c0 rjmp .+232 ; 0x10e <__bad_interrupt>
26: 00 00 nop
../../../../crt1/gcrt1.S:76
28: 72 c0 rjmp .+228 ; 0x10e <__bad_interrupt>
2a: 00 00 nop
../../../../crt1/gcrt1.S:77
2c: 70 c0 rjmp .+224 ; 0x10e <__bad_interrupt>
2e: 00 00 nop
../../../../crt1/gcrt1.S:78
30: 6e c0 rjmp .+220 ; 0x10e <__bad_interrupt>
32: 00 00 nop
../../../../crt1/gcrt1.S:79
34: 6c c0 rjmp .+216 ; 0x10e <__bad_interrupt>
36: 00 00 nop
../../../../crt1/gcrt1.S:80
38: 6a c0 rjmp .+212 ; 0x10e <__bad_interrupt>
3a: 00 00 nop
../../../../crt1/gcrt1.S:81
3c: b1 c3 rjmp .+1890 ; 0x7a0 <__vector_15>
3e: 00 00 nop
../../../../crt1/gcrt1.S:82
40: 66 c0 rjmp .+204 ; 0x10e <__bad_interrupt>
42: 00 00 nop
../../../../crt1/gcrt1.S:83
44: 64 c0 rjmp .+200 ; 0x10e <__bad_interrupt>
46: 00 00 nop
../../../../crt1/gcrt1.S:84
48: 62 c0 rjmp .+196 ; 0x10e <__bad_interrupt>
4a: 00 00 nop
../../../../crt1/gcrt1.S:85
4c: 60 c0 rjmp .+192 ; 0x10e <__bad_interrupt>
4e: 00 00 nop
../../../../crt1/gcrt1.S:86
50: 5e c0 rjmp .+188 ; 0x10e <__bad_interrupt>
52: 00 00 nop
../../../../crt1/gcrt1.S:87
54: 5c c0 rjmp .+184 ; 0x10e <__bad_interrupt>
56: 00 00 nop
../../../../crt1/gcrt1.S:88
58: 5a c0 rjmp .+180 ; 0x10e <__bad_interrupt>
5a: 00 00 nop
../../../../crt1/gcrt1.S:89
5c: 58 c0 rjmp .+176 ; 0x10e <__bad_interrupt>
5e: 00 00 nop
../../../../crt1/gcrt1.S:90
60: 56 c0 rjmp .+172 ; 0x10e <__bad_interrupt>
62: 00 00 nop
../../../../crt1/gcrt1.S:91
64: 54 c0 rjmp .+168 ; 0x10e <__bad_interrupt>
66: 00 00 nop
../../../../crt1/gcrt1.S:92
68: 52 c0 rjmp .+164 ; 0x10e <__bad_interrupt>
6a: 00 00 nop
../../../../crt1/gcrt1.S:93
6c: 50 c0 rjmp .+160 ; 0x10e <__bad_interrupt>
6e: 00 00 nop
../../../../crt1/gcrt1.S:94
70: 4e c0 rjmp .+156 ; 0x10e <__bad_interrupt>
72: 00 00 nop
../../../../crt1/gcrt1.S:95
74: 4c c0 rjmp .+152 ; 0x10e <__bad_interrupt>
76: 00 00 nop
../../../../crt1/gcrt1.S:96
78: 4a c0 rjmp .+148 ; 0x10e <__bad_interrupt>
7a: 00 00 nop
7c: 08 00 .word 0x0008 ; ????
7e: 00 00 nop
80: be 92 st -X, r11
82: 24 49 sbci r18, 0x94 ; 148
84: 12 3e cpi r17, 0xE2 ; 226
86: ab aa std Y+51, r10 ; 0x33
88: aa 2a or r10, r26
8a: be cd rjmp .-1156 ; 0xfffffc08 <__eeprom_end+0xff7efc08>
8c: cc cc rjmp .-1640 ; 0xfffffa26 <__eeprom_end+0xff7efa26>
8e: 4c 3e cpi r20, 0xEC ; 236
90: 00 00 nop
92: 00 80 ld r0, Z
94: be ab std Y+54, r27 ; 0x36
96: aa aa std Y+50, r10 ; 0x32
98: aa 3e cpi r26, 0xEA ; 234
9a: 00 00 nop
9c: 00 00 nop
9e: bf 00 .word 0x00bf ; ????
a0: 00 00 nop
a2: 80 3f cpi r24, 0xF0 ; 240
a4: 00 00 nop
a6: 00 00 nop
a8: 00 08 sbc r0, r0
aa: 41 78 andi r20, 0x81 ; 129
ac: d3 bb out 0x13, r29 ; 19
ae: 43 87 std Z+11, r20 ; 0x0b
b0: d1 13 cpse r29, r17
b2: 3d 19 sub r19, r13
b4: 0e 3c cpi r16, 0xCE ; 206
b6: c3 bd out 0x23, r28 ; 35
b8: 42 82 std Z+2, r4 ; 0x02
ba: ad 2b or r26, r29
bc: 3e 68 ori r19, 0x8E ; 142
be: ec 82 std Y+4, r14 ; 0x04
c0: 76 be out 0x36, r7 ; 54
c2: d9 8f std Y+25, r29 ; 0x19
c4: e1 a9 ldd r30, Z+49 ; 0x31
c6: 3e 4c sbci r19, 0xCE ; 206
c8: 80 ef ldi r24, 0xF0 ; 240
ca: ff be out 0x3f, r15 ; 63
cc: 01 c4 rjmp .+2050 ; 0x8d0 <__DATA_REGION_LENGTH__+0xd0>
ce: ff 7f andi r31, 0xFF ; 255
d0: 3f 00 .word 0x003f ; ????
d2: 00 00 nop
...
000000d6 <__ctors_end>:
__trampolines_start():
../../../../crt1/gcrt1.S:230
d6: 11 24 eor r1, r1
../../../../crt1/gcrt1.S:231
d8: 1f be out 0x3f, r1 ; 63
../../../../crt1/gcrt1.S:232
da: cf ef ldi r28, 0xFF ; 255
../../../../crt1/gcrt1.S:234
dc: cd bf out 0x3d, r28 ; 61
../../../../crt1/gcrt1.S:236
de: df e3 ldi r29, 0x3F ; 63
../../../../crt1/gcrt1.S:237
e0: de bf out 0x3e, r29 ; 62
000000e2 <_initThreeStuff()>:
_Z15_initThreeStuffv():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/main.cpp:104
/* Minimum: Reset if we wound up here through malfunction - this relies on user clearing the *
* register on startup, which is rarely done in Arduino land. */
void __attribute__((weak)) init_reset_flags() ;
void __attribute__((weak)) init_reset_flags() {
uint8_t flags = RSTCTRL.RSTFR;
e2: 80 91 40 00 lds r24, 0x0040 ; 0x800040 <digital_pin_to_bit_mask+0x7f6fd1>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/main.cpp:105
RSTCTRL.RSTFR = flags;
e6: 80 93 40 00 sts 0x0040, r24 ; 0x800040 <digital_pin_to_bit_mask+0x7f6fd1>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/main.cpp:106
if (flags == 0) {
ea: 81 11 cpse r24, r1
ec: 05 c0 rjmp .+10 ; 0xf8 <_initThreeStuff()+0x16>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/main.cpp:107
_PROTECTED_WRITE(RSTCTRL.SWRR, 1);
ee: 98 ed ldi r25, 0xD8 ; 216
f0: 21 e0 ldi r18, 0x01 ; 1
f2: 94 bf out 0x34, r25 ; 52
f4: 20 93 41 00 sts 0x0041, r18 ; 0x800041 <digital_pin_to_bit_mask+0x7f6fd2>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/main.cpp:109
}
GPIOR0 = flags;
f8: 8c bb out 0x1c, r24 ; 28
000000fa <__do_clear_bss>:
__do_clear_bss():
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:2441
fa: 2a e3 ldi r18, 0x3A ; 58
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:2442
fc: a0 e0 ldi r26, 0x00 ; 0
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:2443
fe: b8 e3 ldi r27, 0x38 ; 56
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:2444
100: 01 c0 rjmp .+2 ; 0x104 <.do_clear_bss_start>
00000102 <.do_clear_bss_loop>:
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:2446
102: 1d 92 st X+, r1
00000104 <.do_clear_bss_start>:
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:2448
104: aa 30 cpi r26, 0x0A ; 10
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:2449
106: b2 07 cpc r27, r18
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:2450
108: e1 f7 brne .-8 ; 0x102 <.do_clear_bss_loop>
.do_clear_bss_start():
../../../../crt1/gcrt1.S:314
10a: 79 d3 rcall .+1778 ; 0x7fe <main>
../../../../crt1/gcrt1.S:315
10c: 80 c7 rjmp .+3840 ; 0x100e <_exit>
0000010e <__bad_interrupt>:
__vector_22():
10e: 78 cf rjmp .-272 ; 0x0 <__vectors>
00000110 <tuner::estimate(int const*) [clone .constprop.3]>:
_ZN5tuner8estimateEPKi.constprop.3():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:14
constexpr uint16_t lastLag = 119;
// Input is signed, mean-removed, 10-bit ADC data. Fixed bounds keep SRAM use
// predictable on the ATtiny1616. Scores use the same normalization for peak
// selection and interpolation, unlike the earlier raw-correlation interpolator.
inline float estimate(const int16_t* samples) {
110: 2f 92 push r2
112: 3f 92 push r3
114: 4f 92 push r4
116: 5f 92 push r5
118: 6f 92 push r6
11a: 7f 92 push r7
11c: 8f 92 push r8
11e: 9f 92 push r9
120: af 92 push r10
122: bf 92 push r11
124: cf 92 push r12
126: df 92 push r13
128: ef 92 push r14
12a: ff 92 push r15
12c: 0f 93 push r16
12e: 1f 93 push r17
130: cf 93 push r28
132: df 93 push r29
134: cd b7 in r28, 0x3d ; 61
136: de b7 in r29, 0x3e ; 62
138: c0 5f subi r28, 0xF0 ; 240
13a: d1 40 sbci r29, 0x01 ; 1
13c: cd bf out 0x3d, r28 ; 61
13e: de bf out 0x3e, r29 ; 62
140: 2a e0 ldi r18, 0x0A ; 10
142: 38 e3 ldi r19, 0x38 ; 56
144: cd 51 subi r28, 0x1D ; 29
146: de 4f sbci r29, 0xFE ; 254
148: 28 83 st Y, r18
14a: 39 83 std Y+1, r19 ; 0x01
14c: c3 5e subi r28, 0xE3 ; 227
14e: d1 40 sbci r29, 0x01 ; 1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:15
int32_t energy = 0;
150: c1 2c mov r12, r1
152: d1 2c mov r13, r1
154: 76 01 movw r14, r12
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:17
for (uint16_t i = 0; i < sampleCount; ++i)
energy += (int32_t)samples[i] * samples[i];
156: cd 51 subi r28, 0x1D ; 29
158: de 4f sbci r29, 0xFE ; 254
15a: e8 81 ld r30, Y
15c: f9 81 ldd r31, Y+1 ; 0x01
15e: c3 5e subi r28, 0xE3 ; 227
160: d1 40 sbci r29, 0x01 ; 1
162: a1 91 ld r26, Z+
164: b1 91 ld r27, Z+
166: cd 51 subi r28, 0x1D ; 29
168: de 4f sbci r29, 0xFE ; 254
16a: e8 83 st Y, r30
16c: f9 83 std Y+1, r31 ; 0x01
16e: c3 5e subi r28, 0xE3 ; 227
170: d1 40 sbci r29, 0x01 ; 1
172: 9d 01 movw r18, r26
174: 05 d7 rcall .+3594 ; 0xf80 <__mulhisi3>
176: c6 0e add r12, r22
178: d7 1e adc r13, r23
17a: e8 1e adc r14, r24
17c: f9 1e adc r15, r25
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:16
// Input is signed, mean-removed, 10-bit ADC data. Fixed bounds keep SRAM use
// predictable on the ATtiny1616. Scores use the same normalization for peak
// selection and interpolation, unlike the earlier raw-correlation interpolator.
inline float estimate(const int16_t* samples) {
int32_t energy = 0;
for (uint16_t i = 0; i < sampleCount; ++i)
17e: ea 50 subi r30, 0x0A ; 10
180: fa 43 sbci r31, 0x3A ; 58
182: 49 f7 brne .-46 ; 0x156 <tuner::estimate(int const*) [clone .constprop.3]+0x46>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:18
energy += (int32_t)samples[i] * samples[i];
if (energy < 1024) return 0;
184: c1 14 cp r12, r1
186: 34 e0 ldi r19, 0x04 ; 4
188: d3 06 cpc r13, r19
18a: e1 04 cpc r14, r1
18c: f1 04 cpc r15, r1
18e: 0c f4 brge .+2 ; 0x192 <tuner::estimate(int const*) [clone .constprop.3]+0x82>
190: be c1 rjmp .+892 ; 0x50e <__LOCK_REGION_LENGTH__+0x10e>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:20
float score[lastLag + 1] = {};
192: 80 ee ldi r24, 0xE0 ; 224
194: 91 e0 ldi r25, 0x01 ; 1
196: fe 01 movw r30, r28
198: 31 96 adiw r30, 0x01 ; 1
19a: df 01 movw r26, r30
19c: 9c 01 movw r18, r24
19e: 1d 92 st X+, r1
1a0: 21 50 subi r18, 0x01 ; 1
1a2: 30 40 sbci r19, 0x00 ; 0
1a4: e1 f7 brne .-8 ; 0x19e <tuner::estimate(int const*) [clone .constprop.3]+0x8e>
1a6: ae 01 movw r20, r28
1a8: 4b 5a subi r20, 0xAB ; 171
1aa: 5f 4f sbci r21, 0xFF ; 255
1ac: cf 51 subi r28, 0x1F ; 31
1ae: de 4f sbci r29, 0xFE ; 254
1b0: 48 83 st Y, r20
1b2: 59 83 std Y+1, r21 ; 0x01
1b4: c1 5e subi r28, 0xE1 ; 225
1b6: d1 40 sbci r29, 0x01 ; 1
1b8: c1 51 subi r28, 0x11 ; 17
1ba: de 4f sbci r29, 0xFE ; 254
1bc: 48 83 st Y, r20
1be: 59 83 std Y+1, r21 ; 0x01
1c0: cf 5e subi r28, 0xEF ; 239
1c2: d1 40 sbci r29, 0x01 ; 1
1c4: 4b ee ldi r20, 0xEB ; 235
1c6: 84 2e mov r8, r20
1c8: 91 2c mov r9, r1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:21
float strongest = 0;
1ca: a1 2c mov r10, r1
1cc: b1 2c mov r11, r1
1ce: 00 e0 ldi r16, 0x00 ; 0
1d0: 10 e0 ldi r17, 0x00 ; 0
1d2: c4 01 movw r24, r8
1d4: 88 0f add r24, r24
1d6: 99 1f adc r25, r25
1d8: cd 51 subi r28, 0x1D ; 29
1da: de 4f sbci r29, 0xFE ; 254
1dc: a8 81 ld r26, Y
1de: b9 81 ldd r27, Y+1 ; 0x01
1e0: c3 5e subi r28, 0xE3 ; 227
1e2: d1 40 sbci r29, 0x01 ; 1
1e4: a8 1b sub r26, r24
1e6: b9 0b sbc r27, r25
1e8: c5 51 subi r28, 0x15 ; 21
1ea: de 4f sbci r29, 0xFE ; 254
1ec: a8 83 st Y, r26
1ee: b9 83 std Y+1, r27 ; 0x01
1f0: cb 5e subi r28, 0xEB ; 235
1f2: d1 40 sbci r29, 0x01 ; 1
1f4: ea e0 ldi r30, 0x0A ; 10
1f6: f8 e3 ldi r31, 0x38 ; 56
1f8: c3 51 subi r28, 0x13 ; 19
1fa: de 4f sbci r29, 0xFE ; 254
1fc: e8 83 st Y, r30
1fe: f9 83 std Y+1, r31 ; 0x01
200: cd 5e subi r28, 0xED ; 237
202: d1 40 sbci r29, 0x01 ; 1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:24
for (uint16_t lag = firstLag; lag <= lastLag; ++lag) {
int32_t cross = 0, a2 = 0, b2 = 0;
for (uint16_t i = 0; i < sampleCount - lag; ++i) {
204: 31 2c mov r3, r1
206: 21 2c mov r2, r1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:23
if (energy < 1024) return 0;
float score[lastLag + 1] = {};
float strongest = 0;
for (uint16_t lag = firstLag; lag <= lastLag; ++lag) {
int32_t cross = 0, a2 = 0, b2 = 0;
208: c1 2c mov r12, r1
20a: d1 2c mov r13, r1
20c: 76 01 movw r14, r12
20e: c9 51 subi r28, 0x19 ; 25
210: de 4f sbci r29, 0xFE ; 254
212: 18 82 st Y, r1
214: 19 82 std Y+1, r1 ; 0x01
216: 1a 82 std Y+2, r1 ; 0x02
218: 1b 82 std Y+3, r1 ; 0x03
21a: c7 5e subi r28, 0xE7 ; 231
21c: d1 40 sbci r29, 0x01 ; 1
21e: 41 2c mov r4, r1
220: 51 2c mov r5, r1
222: 32 01 movw r6, r4
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:24
for (uint16_t i = 0; i < sampleCount - lag; ++i) {
224: 28 14 cp r2, r8
226: 39 04 cpc r3, r9
228: 08 f0 brcs .+2 ; 0x22c <tuner::estimate(int const*) [clone .constprop.3]+0x11c>
22a: 44 c0 rjmp .+136 ; 0x2b4 <tuner::estimate(int const*) [clone .constprop.3]+0x1a4>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:25
const int16_t a = samples[i], b = samples[i + lag];
22c: c3 51 subi r28, 0x13 ; 19
22e: de 4f sbci r29, 0xFE ; 254
230: e8 81 ld r30, Y
232: f9 81 ldd r31, Y+1 ; 0x01
234: cd 5e subi r28, 0xED ; 237
236: d1 40 sbci r29, 0x01 ; 1
238: 41 91 ld r20, Z+
23a: 51 91 ld r21, Z+
23c: c3 51 subi r28, 0x13 ; 19
23e: de 4f sbci r29, 0xFE ; 254
240: e8 83 st Y, r30
242: f9 83 std Y+1, r31 ; 0x01
244: cd 5e subi r28, 0xED ; 237
246: d1 40 sbci r29, 0x01 ; 1
248: c5 51 subi r28, 0x15 ; 21
24a: de 4f sbci r29, 0xFE ; 254
24c: a8 81 ld r26, Y
24e: b9 81 ldd r27, Y+1 ; 0x01
250: cb 5e subi r28, 0xEB ; 235
252: d1 40 sbci r29, 0x01 ; 1
254: ed 91 ld r30, X+
256: fd 91 ld r31, X+
258: c5 51 subi r28, 0x15 ; 21
25a: de 4f sbci r29, 0xFE ; 254
25c: a8 83 st Y, r26
25e: b9 83 std Y+1, r27 ; 0x01
260: cb 5e subi r28, 0xEB ; 235
262: d1 40 sbci r29, 0x01 ; 1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:26
cross += (int32_t)a * b;
264: 9a 01 movw r18, r20
266: df 01 movw r26, r30
268: 8b d6 rcall .+3350 ; 0xf80 <__mulhisi3>
26a: 46 0e add r4, r22
26c: 57 1e adc r5, r23
26e: 68 1e adc r6, r24
270: 79 1e adc r7, r25
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:27
a2 += (int32_t)a * a;
272: da 01 movw r26, r20
274: 85 d6 rcall .+3338 ; 0xf80 <__mulhisi3>
276: c9 51 subi r28, 0x19 ; 25
278: de 4f sbci r29, 0xFE ; 254
27a: 28 81 ld r18, Y
27c: 39 81 ldd r19, Y+1 ; 0x01
27e: 4a 81 ldd r20, Y+2 ; 0x02
280: 5b 81 ldd r21, Y+3 ; 0x03
282: c7 5e subi r28, 0xE7 ; 231
284: d1 40 sbci r29, 0x01 ; 1
286: 26 0f add r18, r22
288: 37 1f adc r19, r23
28a: 48 1f adc r20, r24
28c: 59 1f adc r21, r25
28e: c9 51 subi r28, 0x19 ; 25
290: de 4f sbci r29, 0xFE ; 254
292: 28 83 st Y, r18
294: 39 83 std Y+1, r19 ; 0x01
296: 4a 83 std Y+2, r20 ; 0x02
298: 5b 83 std Y+3, r21 ; 0x03
29a: c7 5e subi r28, 0xE7 ; 231
29c: d1 40 sbci r29, 0x01 ; 1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:28
b2 += (int32_t)b * b;
29e: 9f 01 movw r18, r30
2a0: df 01 movw r26, r30
2a2: 6e d6 rcall .+3292 ; 0xf80 <__mulhisi3>
2a4: c6 0e add r12, r22
2a6: d7 1e adc r13, r23
2a8: e8 1e adc r14, r24
2aa: f9 1e adc r15, r25
2ac: 3f ef ldi r19, 0xFF ; 255
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:24
float score[lastLag + 1] = {};
float strongest = 0;
for (uint16_t lag = firstLag; lag <= lastLag; ++lag) {
int32_t cross = 0, a2 = 0, b2 = 0;
for (uint16_t i = 0; i < sampleCount - lag; ++i) {
2ae: 23 1a sub r2, r19
2b0: 33 0a sbc r3, r19
2b2: b8 cf rjmp .-144 ; 0x224 <tuner::estimate(int const*) [clone .constprop.3]+0x114>
2b4: c9 51 subi r28, 0x19 ; 25
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:30
const int16_t a = samples[i], b = samples[i + lag];
cross += (int32_t)a * b;
a2 += (int32_t)a * a;
b2 += (int32_t)b * b;
}
score[lag] = a2 + b2 ? (2.0f * cross) / (a2 + b2) : 0;
2b6: de 4f sbci r29, 0xFE ; 254
2b8: 88 81 ld r24, Y
2ba: 99 81 ldd r25, Y+1 ; 0x01
2bc: aa 81 ldd r26, Y+2 ; 0x02
2be: bb 81 ldd r27, Y+3 ; 0x03
2c0: c7 5e subi r28, 0xE7 ; 231
2c2: d1 40 sbci r29, 0x01 ; 1
2c4: c8 0e add r12, r24
2c6: d9 1e adc r13, r25
2c8: ea 1e adc r14, r26
2ca: fb 1e adc r15, r27
2cc: c1 14 cp r12, r1
2ce: d1 04 cpc r13, r1
2d0: e1 04 cpc r14, r1
2d2: f1 04 cpc r15, r1
2d4: 09 f4 brne .+2 ; 0x2d8 <tuner::estimate(int const*) [clone .constprop.3]+0x1c8>
2d6: 04 c1 rjmp .+520 ; 0x4e0 <__LOCK_REGION_LENGTH__+0xe0>
2d8: c3 01 movw r24, r6
2da: b2 01 movw r22, r4
2dc: a6 d4 rcall .+2380 ; 0xc2a <__floatsisf>
2de: 9b 01 movw r18, r22
2e0: ac 01 movw r20, r24
2e2: d1 d3 rcall .+1954 ; 0xa86 <__addsf3>
2e4: 2b 01 movw r4, r22
2e6: 3c 01 movw r6, r24
2e8: c7 01 movw r24, r14
2ea: b6 01 movw r22, r12
2ec: 9e d4 rcall .+2364 ; 0xc2a <__floatsisf>
2ee: 9b 01 movw r18, r22
2f0: ac 01 movw r20, r24
2f2: c3 01 movw r24, r6
2f4: b2 01 movw r22, r4
2f6: 2f d4 rcall .+2142 ; 0xb56 <__divsf3>
2f8: 6b 01 movw r12, r22
2fa: 7c 01 movw r14, r24
2fc: c1 51 subi r28, 0x11 ; 17
2fe: de 4f sbci r29, 0xFE ; 254
300: a8 81 ld r26, Y
302: b9 81 ldd r27, Y+1 ; 0x01
304: cf 5e subi r28, 0xEF ; 239
306: d1 40 sbci r29, 0x01 ; 1
308: cd 92 st X+, r12
30a: dd 92 st X+, r13
30c: ed 92 st X+, r14
30e: fd 92 st X+, r15
310: c1 51 subi r28, 0x11 ; 17
312: de 4f sbci r29, 0xFE ; 254
314: a8 83 st Y, r26
316: b9 83 std Y+1, r27 ; 0x01
318: cf 5e subi r28, 0xEF ; 239
31a: d1 40 sbci r29, 0x01 ; 1
31c: 95 01 movw r18, r10
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:31
if (score[lag] > strongest) strongest = score[lag];
31e: a8 01 movw r20, r16
320: c7 01 movw r24, r14
322: b6 01 movw r22, r12
324: 32 d5 rcall .+2660 ; 0xd8a <__gesf2>
326: 18 16 cp r1, r24
328: 14 f4 brge .+4 ; 0x32e <tuner::estimate(int const*) [clone .constprop.3]+0x21e>
32a: 56 01 movw r10, r12
32c: 87 01 movw r16, r14
32e: b1 e0 ldi r27, 0x01 ; 1
330: 8b 1a sub r8, r27
332: 91 08 sbc r9, r1
334: e8 e8 ldi r30, 0x88 ; 136
336: 8e 16 cp r8, r30
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:22
energy += (int32_t)samples[i] * samples[i];
if (energy < 1024) return 0;
float score[lastLag + 1] = {};
float strongest = 0;
for (uint16_t lag = firstLag; lag <= lastLag; ++lag) {
338: 91 04 cpc r9, r1
33a: 09 f0 breq .+2 ; 0x33e <tuner::estimate(int const*) [clone .constprop.3]+0x22e>
33c: 4a cf rjmp .-364 ; 0x1d2 <tuner::estimate(int const*) [clone .constprop.3]+0xc2>
33e: 2d ec ldi r18, 0xCD ; 205
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:33
b2 += (int32_t)b * b;
}
score[lag] = a2 + b2 ? (2.0f * cross) / (a2 + b2) : 0;
if (score[lag] > strongest) strongest = score[lag];
}
if (strongest < 0.8f) return 0;
340: 3c ec ldi r19, 0xCC ; 204
342: 4c e4 ldi r20, 0x4C ; 76
344: 5f e3 ldi r21, 0x3F ; 63
346: b5 01 movw r22, r10
348: c8 01 movw r24, r16
34a: 01 d4 rcall .+2050 ; 0xb4e <__cmpsf2>
34c: 87 fd sbrc r24, 7
34e: df c0 rjmp .+446 ; 0x50e <__LOCK_REGION_LENGTH__+0x10e>
350: 2b e7 ldi r18, 0x7B ; 123
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:38
// Pick the earliest strong local peak, avoiding 2x/3x-period octave errors.
for (uint16_t lag = firstLag + 1; lag < lastLag; ++lag) {
const float left = score[lag - 1], mid = score[lag], right = score[lag + 1];
if (mid < 0.93f * strongest || mid <= left || mid < right) continue;
352: 34 e1 ldi r19, 0x14 ; 20
354: 4e e6 ldi r20, 0x6E ; 110
356: 5f e3 ldi r21, 0x3F ; 63
358: b5 01 movw r22, r10
35a: c8 01 movw r24, r16
35c: 5f d5 rcall .+2750 ; 0xe1c <__mulsf3>
35e: cd 51 subi r28, 0x1D ; 29
360: de 4f sbci r29, 0xFE ; 254
362: 68 83 st Y, r22
364: 79 83 std Y+1, r23 ; 0x01
366: 8a 83 std Y+2, r24 ; 0x02
368: 9b 83 std Y+3, r25 ; 0x03
36a: c3 5e subi r28, 0xE3 ; 227
36c: d1 40 sbci r29, 0x01 ; 1
36e: 26 e1 ldi r18, 0x16 ; 22
370: 22 2e mov r2, r18
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:36
if (score[lag] > strongest) strongest = score[lag];
}
if (strongest < 0.8f) return 0;
// Pick the earliest strong local peak, avoiding 2x/3x-period octave errors.
for (uint16_t lag = firstLag + 1; lag < lastLag; ++lag) {
372: 31 2c mov r3, r1
374: cf 51 subi r28, 0x1F ; 31
376: de 4f sbci r29, 0xFE ; 254
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:37
const float left = score[lag - 1], mid = score[lag], right = score[lag + 1];
378: a8 81 ld r26, Y
37a: b9 81 ldd r27, Y+1 ; 0x01
37c: c1 5e subi r28, 0xE1 ; 225
37e: d1 40 sbci r29, 0x01 ; 1
380: 14 96 adiw r26, 0x04 ; 4
382: cd 90 ld r12, X+
384: dd 90 ld r13, X+
386: ed 90 ld r14, X+
388: fc 90 ld r15, X
38a: 17 97 sbiw r26, 0x07 ; 7
38c: 81 01 movw r16, r2
38e: 0f 5f subi r16, 0xFF ; 255
390: 1f 4f sbci r17, 0xFF ; 255
392: cd 51 subi r28, 0x1D ; 29
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:38
if (mid < 0.93f * strongest || mid <= left || mid < right) continue;
394: de 4f sbci r29, 0xFE ; 254
396: 28 81 ld r18, Y
398: 39 81 ldd r19, Y+1 ; 0x01
39a: 4a 81 ldd r20, Y+2 ; 0x02
39c: 5b 81 ldd r21, Y+3 ; 0x03
39e: c3 5e subi r28, 0xE3 ; 227
3a0: d1 40 sbci r29, 0x01 ; 1
3a2: c7 01 movw r24, r14
3a4: b6 01 movw r22, r12
3a6: d3 d3 rcall .+1958 ; 0xb4e <__cmpsf2>
3a8: 87 fd sbrc r24, 7
3aa: 9e c0 rjmp .+316 ; 0x4e8 <__LOCK_REGION_LENGTH__+0xe8>
3ac: cf 51 subi r28, 0x1F ; 31
3ae: de 4f sbci r29, 0xFE ; 254
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:37
}
if (strongest < 0.8f) return 0;
// Pick the earliest strong local peak, avoiding 2x/3x-period octave errors.
for (uint16_t lag = firstLag + 1; lag < lastLag; ++lag) {
const float left = score[lag - 1], mid = score[lag], right = score[lag + 1];
3b0: e8 81 ld r30, Y
3b2: f9 81 ldd r31, Y+1 ; 0x01
3b4: c1 5e subi r28, 0xE1 ; 225
3b6: d1 40 sbci r29, 0x01 ; 1
3b8: 80 80 ld r8, Z
3ba: 91 80 ldd r9, Z+1 ; 0x01
3bc: a2 80 ldd r10, Z+2 ; 0x02
3be: b3 80 ldd r11, Z+3 ; 0x03
3c0: a7 01 movw r20, r14
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:38
if (mid < 0.93f * strongest || mid <= left || mid < right) continue;
3c2: 96 01 movw r18, r12
3c4: c5 01 movw r24, r10
3c6: b4 01 movw r22, r8
3c8: e0 d4 rcall .+2496 ; 0xd8a <__gesf2>
3ca: 87 ff sbrs r24, 7
3cc: 8d c0 rjmp .+282 ; 0x4e8 <__LOCK_REGION_LENGTH__+0xe8>
3ce: cf 51 subi r28, 0x1F ; 31
3d0: de 4f sbci r29, 0xFE ; 254
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:37
}
if (strongest < 0.8f) return 0;
// Pick the earliest strong local peak, avoiding 2x/3x-period octave errors.
for (uint16_t lag = firstLag + 1; lag < lastLag; ++lag) {
const float left = score[lag - 1], mid = score[lag], right = score[lag + 1];
3d2: a8 81 ld r26, Y
3d4: b9 81 ldd r27, Y+1 ; 0x01
3d6: c1 5e subi r28, 0xE1 ; 225
3d8: d1 40 sbci r29, 0x01 ; 1
3da: 18 96 adiw r26, 0x08 ; 8
3dc: 4d 90 ld r4, X+
3de: 5d 90 ld r5, X+
3e0: 6d 90 ld r6, X+
3e2: 7c 90 ld r7, X
3e4: 1b 97 sbiw r26, 0x0b ; 11
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:38
if (mid < 0.93f * strongest || mid <= left || mid < right) continue;
3e6: a3 01 movw r20, r6
3e8: 92 01 movw r18, r4
3ea: c7 01 movw r24, r14
3ec: b6 01 movw r22, r12
3ee: af d3 rcall .+1886 ; 0xb4e <__cmpsf2>
3f0: 87 fd sbrc r24, 7
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:39
const float curvature = left - 2 * mid + right;
3f2: 7a c0 rjmp .+244 ; 0x4e8 <__LOCK_REGION_LENGTH__+0xe8>
3f4: a7 01 movw r20, r14
3f6: 96 01 movw r18, r12
3f8: c7 01 movw r24, r14
3fa: b6 01 movw r22, r12
3fc: 44 d3 rcall .+1672 ; 0xa86 <__addsf3>
3fe: 9b 01 movw r18, r22
400: ac 01 movw r20, r24
402: c5 01 movw r24, r10
404: b4 01 movw r22, r8
406: 3e d3 rcall .+1660 ; 0xa84 <__subsf3>
408: a3 01 movw r20, r6
40a: 92 01 movw r18, r4
40c: 3c d3 rcall .+1656 ; 0xa86 <__addsf3>
40e: 6b 01 movw r12, r22
410: 7c 01 movw r14, r24
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:40
float offset = fabsf(curvature) > 0.000001f ? 0.5f * (left - right) / curvature : 0;
412: 9f 77 andi r25, 0x7F ; 127
414: 2d eb ldi r18, 0xBD ; 189
416: 37 e3 ldi r19, 0x37 ; 55
418: 46 e8 ldi r20, 0x86 ; 134
41a: 55 e3 ldi r21, 0x35 ; 53
41c: b6 d4 rcall .+2412 ; 0xd8a <__gesf2>
41e: 18 16 cp r1, r24
420: 0c f0 brlt .+2 ; 0x424 <__LOCK_REGION_LENGTH__+0x24>
422: 79 c0 rjmp .+242 ; 0x516 <__LOCK_REGION_LENGTH__+0x116>
424: a3 01 movw r20, r6
426: 92 01 movw r18, r4
428: c5 01 movw r24, r10
42a: b4 01 movw r22, r8
42c: 2b d3 rcall .+1622 ; 0xa84 <__subsf3>
42e: 20 e0 ldi r18, 0x00 ; 0
430: 30 e0 ldi r19, 0x00 ; 0
432: 40 e0 ldi r20, 0x00 ; 0
434: 5f e3 ldi r21, 0x3F ; 63
436: f2 d4 rcall .+2532 ; 0xe1c <__mulsf3>
438: a7 01 movw r20, r14
43a: 96 01 movw r18, r12
43c: 8c d3 rcall .+1816 ; 0xb56 <__divsf3>
43e: 6b 01 movw r12, r22
440: 7c 01 movw r14, r24
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:41
if (offset > 0.5f) offset = 0.5f;
442: 20 e0 ldi r18, 0x00 ; 0
444: 30 e0 ldi r19, 0x00 ; 0
446: 40 e0 ldi r20, 0x00 ; 0
448: 5f e3 ldi r21, 0x3F ; 63
44a: 9f d4 rcall .+2366 ; 0xd8a <__gesf2>
44c: 18 16 cp r1, r24
44e: 0c f4 brge .+2 ; 0x452 <__LOCK_REGION_LENGTH__+0x52>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:42
if (offset < -0.5f) offset = -0.5f;
450: 66 c0 rjmp .+204 ; 0x51e <__LOCK_REGION_LENGTH__+0x11e>
452: 20 e0 ldi r18, 0x00 ; 0
454: 30 e0 ldi r19, 0x00 ; 0
456: 40 e0 ldi r20, 0x00 ; 0
458: 5f eb ldi r21, 0xBF ; 191
45a: c7 01 movw r24, r14
45c: b6 01 movw r22, r12
45e: 77 d3 rcall .+1774 ; 0xb4e <__cmpsf2>
460: 87 ff sbrs r24, 7
462: 05 c0 rjmp .+10 ; 0x46e <__LOCK_REGION_LENGTH__+0x6e>
464: c1 2c mov r12, r1
466: d1 2c mov r13, r1
468: e1 2c mov r14, r1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:43
const float hz = sampleRate / (lag + offset);
46a: 9f eb ldi r25, 0xBF ; 191
46c: f9 2e mov r15, r25
46e: b1 01 movw r22, r2
470: 90 e0 ldi r25, 0x00 ; 0
472: 80 e0 ldi r24, 0x00 ; 0
474: d8 d3 rcall .+1968 ; 0xc26 <__floatunsisf>
476: a7 01 movw r20, r14
478: 96 01 movw r18, r12
47a: 05 d3 rcall .+1546 ; 0xa86 <__addsf3>
47c: 9b 01 movw r18, r22
47e: ac 01 movw r20, r24
480: 60 e0 ldi r22, 0x00 ; 0
482: 70 e0 ldi r23, 0x00 ; 0
484: 8a ef ldi r24, 0xFA ; 250
486: 95 e4 ldi r25, 0x45 ; 69
488: 66 d3 rcall .+1740 ; 0xb56 <__divsf3>
48a: 6b 01 movw r12, r22
48c: 7c 01 movw r14, r24
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:44
return hz >= 70 && hz <= 360 ? hz : 0;
48e: 20 e0 ldi r18, 0x00 ; 0
490: 30 e0 ldi r19, 0x00 ; 0
492: 4c e8 ldi r20, 0x8C ; 140
494: 52 e4 ldi r21, 0x42 ; 66
496: 79 d4 rcall .+2290 ; 0xd8a <__gesf2>
498: 87 fd sbrc r24, 7
49a: 39 c0 rjmp .+114 ; 0x50e <__LOCK_REGION_LENGTH__+0x10e>
49c: 20 e0 ldi r18, 0x00 ; 0
49e: 30 e0 ldi r19, 0x00 ; 0
4a0: 44 eb ldi r20, 0xB4 ; 180
4a2: 53 e4 ldi r21, 0x43 ; 67
4a4: c7 01 movw r24, r14
4a6: b6 01 movw r22, r12
4a8: 52 d3 rcall .+1700 ; 0xb4e <__cmpsf2>
4aa: 18 16 cp r1, r24
4ac: 84 f1 brlt .+96 ; 0x50e <__LOCK_REGION_LENGTH__+0x10e>
4ae: c7 01 movw r24, r14
4b0: b6 01 movw r22, r12
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:47
}
return 0;
}
4b2: c0 51 subi r28, 0x10 ; 16
4b4: de 4f sbci r29, 0xFE ; 254
4b6: cd bf out 0x3d, r28 ; 61
4b8: de bf out 0x3e, r29 ; 62
4ba: df 91 pop r29
4bc: cf 91 pop r28
4be: 1f 91 pop r17
4c0: 0f 91 pop r16
4c2: ff 90 pop r15
4c4: ef 90 pop r14
4c6: df 90 pop r13
4c8: cf 90 pop r12
4ca: bf 90 pop r11
4cc: af 90 pop r10
4ce: 9f 90 pop r9
4d0: 8f 90 pop r8
4d2: 7f 90 pop r7
4d4: 6f 90 pop r6
4d6: 5f 90 pop r5
4d8: 4f 90 pop r4
4da: 3f 90 pop r3
4dc: 2f 90 pop r2
4de: 08 95 ret
4e0: c1 2c mov r12, r1
4e2: d1 2c mov r13, r1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:30
const int16_t a = samples[i], b = samples[i + lag];
cross += (int32_t)a * b;
a2 += (int32_t)a * a;
b2 += (int32_t)b * b;
}
score[lag] = a2 + b2 ? (2.0f * cross) / (a2 + b2) : 0;
4e4: 76 01 movw r14, r12
4e6: 0a cf rjmp .-492 ; 0x2fc <tuner::estimate(int const*) [clone .constprop.3]+0x1ec>
4e8: cf 51 subi r28, 0x1F ; 31
4ea: de 4f sbci r29, 0xFE ; 254
4ec: 28 81 ld r18, Y
4ee: 39 81 ldd r19, Y+1 ; 0x01
4f0: c1 5e subi r28, 0xE1 ; 225
4f2: d1 40 sbci r29, 0x01 ; 1
4f4: 2c 5f subi r18, 0xFC ; 252
4f6: 3f 4f sbci r19, 0xFF ; 255
4f8: cf 51 subi r28, 0x1F ; 31
4fa: de 4f sbci r29, 0xFE ; 254
4fc: 28 83 st Y, r18
4fe: 39 83 std Y+1, r19 ; 0x01
500: c1 5e subi r28, 0xE1 ; 225
502: d1 40 sbci r29, 0x01 ; 1
504: 18 01 movw r2, r16
506: 07 37 cpi r16, 0x77 ; 119
508: 11 05 cpc r17, r1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:36
if (score[lag] > strongest) strongest = score[lag];
}
if (strongest < 0.8f) return 0;
// Pick the earliest strong local peak, avoiding 2x/3x-period octave errors.
for (uint16_t lag = firstLag + 1; lag < lastLag; ++lag) {
50a: 09 f0 breq .+2 ; 0x50e <__LOCK_REGION_LENGTH__+0x10e>
50c: 33 cf rjmp .-410 ; 0x374 <tuner::estimate(int const*) [clone .constprop.3]+0x264>
50e: c1 2c mov r12, r1
510: d1 2c mov r13, r1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:44
const float curvature = left - 2 * mid + right;
float offset = fabsf(curvature) > 0.000001f ? 0.5f * (left - right) / curvature : 0;
if (offset > 0.5f) offset = 0.5f;
if (offset < -0.5f) offset = -0.5f;
const float hz = sampleRate / (lag + offset);
return hz >= 70 && hz <= 360 ? hz : 0;
512: 76 01 movw r14, r12
514: cc cf rjmp .-104 ; 0x4ae <__LOCK_REGION_LENGTH__+0xae>
516: c1 2c mov r12, r1
518: d1 2c mov r13, r1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:40
// Pick the earliest strong local peak, avoiding 2x/3x-period octave errors.
for (uint16_t lag = firstLag + 1; lag < lastLag; ++lag) {
const float left = score[lag - 1], mid = score[lag], right = score[lag + 1];
if (mid < 0.93f * strongest || mid <= left || mid < right) continue;
const float curvature = left - 2 * mid + right;
float offset = fabsf(curvature) > 0.000001f ? 0.5f * (left - right) / curvature : 0;
51a: 76 01 movw r14, r12
51c: a8 cf rjmp .-176 ; 0x46e <__LOCK_REGION_LENGTH__+0x6e>
51e: c1 2c mov r12, r1
520: d1 2c mov r13, r1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/pitch_detector.h:41
if (offset > 0.5f) offset = 0.5f;
522: e1 2c mov r14, r1
524: 8f e3 ldi r24, 0x3F ; 63
526: f8 2e mov r15, r24
528: a2 cf rjmp .-188 ; 0x46e <__LOCK_REGION_LENGTH__+0x6e>
0000052a <micros>:
micros():
52a: cf 92 push r12
52c: df 92 push r13
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:403
}
#if !(defined(MILLIS_USE_TIMERNONE) || defined(MILLIS_USE_TIMERRTC))
unsigned long micros() {
52e: ef 92 push r14
530: ff 92 push r15
532: 9f b7 in r25, 0x3f ; 63
534: f8 94 cli
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:412
#else /* TCA */
uint8_t ticks;
#endif
uint8_t flags;
/* Save current state and disable interrupts */
uint8_t oldSREG = SREG;
536: 88 e0 ldi r24, 0x08 ; 8
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:413
cli(); /* INTERRUPTS OFF */
538: 80 93 84 0a sts 0x0A84, r24 ; 0x800a84 <digital_pin_to_bit_mask+0x7f7a15>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:421
flags = _timer->INTFLAGS;
#elif defined(MILLIS_USE_TIMERA0)
ticks = TCA0.SPLIT.HCNT;
flags = TCA0.SPLIT.INTFLAGS;
#elif defined(MILLIS_USE_TIMERD0)
TCD0.CTRLE = TCD_SCAPTUREA_bm;
53c: 80 91 8e 0a lds r24, 0x0A8E ; 0x800a8e <digital_pin_to_bit_mask+0x7f7a1f>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:422
while (!(TCD0.STATUS & TCD_CMDRDY_bm)); // wait for sync - should be only one iteration of this loop
540: 81 ff sbrs r24, 1
542: fc cf rjmp .-8 ; 0x53c <micros+0x12>
544: 80 91 8d 0a lds r24, 0x0A8D ; 0x800a8d <digital_pin_to_bit_mask+0x7f7a1e>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:423
flags = TCD0.INTFLAGS;
548: e0 91 a2 0a lds r30, 0x0AA2 ; 0x800aa2 <digital_pin_to_bit_mask+0x7f7a33>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:424
ticks = TCD0.CAPTUREA;
54c: f0 91 a3 0a lds r31, 0x0AA3 ; 0x800aa3 <digital_pin_to_bit_mask+0x7f7a34>
550: c0 90 00 38 lds r12, 0x3800 ; 0x803800 <__DATA_REGION_ORIGIN__>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:434
* ISR has not fired. If we already read a high value of ticks, either we read it just before the overflow,
* so we shouldn't increment overflows, or interrupts are disabled and micros isn't expected to work so it
* doesn't matter.
* Get current number of overflows and timer count */
#if (MILLIS_TYPE != MILLIS_TCB)
overflows = timingStruct.timer_overflow_count;
554: d0 90 01 38 lds r13, 0x3801 ; 0x803801 <__DATA_REGION_ORIGIN__+0x1>
558: e0 90 02 38 lds r14, 0x3802 ; 0x803802 <__DATA_REGION_ORIGIN__+0x2>
55c: f0 90 03 38 lds r15, 0x3803 ; 0x803803 <__DATA_REGION_ORIGIN__+0x3>
560: 9f bf out 0x3f, r25 ; 63
562: 80 ff sbrs r24, 0
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:439
#else
overflows = timingStruct.timer_millis;
#endif
/* Turn interrupts back on, assuming they were on when micros was called. */
SREG = oldSREG; /* INTERRUPTS ON */
564: 08 c0 rjmp .+16 ; 0x576 <micros+0x4c>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:441
#if defined(MILLIS_USE_TIMERD0)
if ((flags & TCD_OVF_bm) && (ticks < 0x07)) {
566: e7 30 cpi r30, 0x07 ; 7
568: f1 05 cpc r31, r1
56a: 28 f4 brcc .+10 ; 0x576 <micros+0x4c>
56c: 8f ef ldi r24, 0xFF ; 255
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:451
if ((flags & TCB_CAPT_bm) && !(ticks & 0xFF00)) {
#endif
#if (MILLIS_TYPE == MILLIS_TCB) && !(F_CPU > 2000000UL)
overflows +=2;
#else
overflows++;
56e: c8 1a sub r12, r24
570: d8 0a sbc r13, r24
572: e8 0a sbc r14, r24
574: f8 0a sbc r15, r24
576: 9f 01 movw r18, r30
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:457
#endif
} // end getting ticks
#if defined(MILLIS_USE_TIMERD0)
#if (F_CPU == 20000000UL || F_CPU == 10000000UL || F_CPU == 5000000UL)
uint8_t ticks_l = ticks >> 1;
578: 36 95 lsr r19
57a: 27 95 ror r18
57c: cf 01 movw r24, r30
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:458
ticks = ticks + ticks_l + ((ticks_l >> 2) - (ticks_l >> 4) + (ticks_l >> 7));
57e: 82 0f add r24, r18
580: 91 1d adc r25, r1
582: e2 2f mov r30, r18
584: e6 95 lsr r30
586: e6 95 lsr r30
588: 32 2f mov r19, r18
58a: 32 95 swap r19
58c: 3f 70 andi r19, 0x0F ; 15
58e: e3 1b sub r30, r19
590: ff 0b sbc r31, r31
592: 27 fd sbrc r18, 7
594: 31 96 adiw r30, 0x01 ; 1
596: e8 0f add r30, r24
598: f9 1f adc r31, r25
59a: a0 e3 ldi r26, 0x30 ; 48
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:462
// + ticks +(ticks>>1)+(ticks>>3)-(ticks>>5)+(ticks>>8))
// speed optimization via doing math with smaller datatypes, since we know high byte is 1 or 0.
//microseconds = overflows * (TIME_TRACKING_CYCLES_PER_OVF / 20) + ticks; // ticks value corrected above. *FIVE HUNDRED AND TEN DOES NOT EVENLY DIVIDE BY 20!* What the fuck?
microseconds = overflows * (TIME_TRACKING_CYCLES_PER_OVF / 20) + ticks + (overflows >> 1);
59c: b3 e0 ldi r27, 0x03 ; 3
59e: a7 01 movw r20, r14
5a0: 96 01 movw r18, r12
5a2: 09 d5 rcall .+2578 ; 0xfb6 <__muluhisi3>
5a4: f6 94 lsr r15
5a6: e7 94 ror r14
5a8: d7 94 ror r13
5aa: c7 94 ror r12
5ac: c6 0e add r12, r22
5ae: d7 1e adc r13, r23
5b0: e8 1e adc r14, r24
5b2: f9 1e adc r15, r25
5b4: c7 01 movw r24, r14
5b6: b6 01 movw r22, r12
5b8: 6e 0f add r22, r30
5ba: 7f 1f adc r23, r31
5bc: 81 1d adc r24, r1
5be: 91 1d adc r25, r1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:800
microseconds = ((overflows * millisClockCyclesToMicroseconds(TIME_TRACKING_CYCLES_PER_OVF))
+ (ticks * (millisClockCyclesToMicroseconds(TIME_TRACKING_CYCLES_PER_OVF) / TIME_TRACKING_TIMER_PERIOD)));
#endif
#endif // end of timer-specific part of micros calculations
return microseconds;
}
5c0: ff 90 pop r15
5c2: ef 90 pop r14
5c4: df 90 pop r13
5c6: cf 90 pop r12
5c8: 08 95 ret
000005ca <delay>:
delay():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:233
_delay_ms(1);
}
}
}
#elif (PROGMEM_SIZE >= 16384 && !defined(MILLIS_USE_TIMERRTC))
void delay(uint32_t ms) { /* Interrupts will not prolong this less flash-efficient delay */
5ca: cf 92 push r12
5cc: df 92 push r13
5ce: ef 92 push r14
5d0: ff 92 push r15
5d2: cf 93 push r28
5d4: df 93 push r29
5d6: 6b 01 movw r12, r22
5d8: 7c 01 movw r14, r24
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:234
uint16_t start = (uint16_t) micros();
5da: a7 df rcall .-178 ; 0x52a <micros>
5dc: eb 01 movw r28, r22
5de: a5 df rcall .-182 ; 0x52a <micros>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:236
while (ms > 0) {
while (((uint16_t) micros() - start) >= 1000 && ms) {
5e0: 6c 1b sub r22, r28
5e2: 7d 0b sbc r23, r29
5e4: 68 3e cpi r22, 0xE8 ; 232
5e6: 73 40 sbci r23, 0x03 ; 3
5e8: a0 f0 brcs .+40 ; 0x612 <delay+0x48>
5ea: c1 14 cp r12, r1
5ec: d1 04 cpc r13, r1
5ee: e1 04 cpc r14, r1
5f0: f1 04 cpc r15, r1
5f2: 39 f4 brne .+14 ; 0x602 <delay+0x38>
5f4: df 91 pop r29
5f6: cf 91 pop r28
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:241
ms-- ;
start += 1000;
}
}
}
5f8: ff 90 pop r15
5fa: ef 90 pop r14
5fc: df 90 pop r13
5fe: cf 90 pop r12
600: 08 95 ret
602: 81 e0 ldi r24, 0x01 ; 1
604: c8 1a sub r12, r24
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:237
#elif (PROGMEM_SIZE >= 16384 && !defined(MILLIS_USE_TIMERRTC))
void delay(uint32_t ms) { /* Interrupts will not prolong this less flash-efficient delay */
uint16_t start = (uint16_t) micros();
while (ms > 0) {
while (((uint16_t) micros() - start) >= 1000 && ms) {
ms-- ;
606: d1 08 sbc r13, r1
608: e1 08 sbc r14, r1
60a: f1 08 sbc r15, r1
60c: c8 51 subi r28, 0x18 ; 24
60e: dc 4f sbci r29, 0xFC ; 252
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:238
start += 1000;
610: e6 cf rjmp .-52 ; 0x5de <delay+0x14>
612: c1 14 cp r12, r1
614: d1 04 cpc r13, r1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:235
}
}
#elif (PROGMEM_SIZE >= 16384 && !defined(MILLIS_USE_TIMERRTC))
void delay(uint32_t ms) { /* Interrupts will not prolong this less flash-efficient delay */
uint16_t start = (uint16_t) micros();
while (ms > 0) {
616: e1 04 cpc r14, r1
618: f1 04 cpc r15, r1
61a: 09 f7 brne .-62 ; 0x5de <delay+0x14>
61c: eb cf rjmp .-42 ; 0x5f4 <delay+0x2a>
0000061e <digitalRead.constprop.2>:
digitalRead.constprop.2():
61e: 80 91 28 04 lds r24, 0x0428 ; 0x800428 <digital_pin_to_bit_mask+0x7f73b9>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:363
/* Get port and check valid port */
PORT_t *port = digitalPinToPortStruct(pin);
/* Read pin value from PORTx.IN register */
if (port->IN & bit_mask) {
622: 81 70 andi r24, 0x01 ; 1
624: 08 95 ret
00000626 <digitalWrite>:
digitalWrite():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:368
return HIGH;
} else {
return LOW;
}
}
626: cf 93 push r28
628: df 93 push r29
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:241
default:
break;
}
}
void digitalWrite(uint8_t pin, uint8_t val) {
62a: 82 31 cpi r24, 0x12 ; 18
62c: 08 f0 brcs .+2 ; 0x630 <digitalWrite+0xa>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:244
check_valid_digital_pin(pin);
/* Get bit mask for pin */
uint8_t bit_mask = digitalPinToBitMask(pin);
62e: 47 c0 rjmp .+142 ; 0x6be <digitalWrite+0x98>
check_valid_digital_pin():
630: 90 e0 ldi r25, 0x00 ; 0
digitalWrite():
632: ec 01 movw r28, r24
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/Arduino.h:888
#if !defined(NUM_TOTAL_PINS)
#define NUM_TOTAL_PINS (NUM_DIGITAL_PINS) /* Used the same way as NUM_DIGITAL_PINS. so it doesn't mean what it's named - I didn't make the convention*/
#endif
inline __attribute__((always_inline)) void check_valid_digital_pin(pin_size_t pin) {
if (__builtin_constant_p(pin)) {
634: c1 59 subi r28, 0x91 ; 145
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:244
636: df 46 sbci r29, 0x6F ; 111
638: 28 81 ld r18, Y
63a: 2f 3f cpi r18, 0xFF ; 255
63c: 09 f4 brne .+2 ; 0x640 <digitalWrite+0x1a>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:245
if (bit_mask == NOT_A_PIN) {
63e: 3f c0 rjmp .+126 ; 0x6be <digitalWrite+0x98>
640: ac 01 movw r20, r24
642: 43 5a subi r20, 0xA3 ; 163
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:250
return;
}
/* Get port */
PORT_t *port = digitalPinToPortStruct(pin);
644: 5f 46 sbci r21, 0x6F ; 111
646: da 01 movw r26, r20
648: ec 91 ld r30, X
64a: b0 e2 ldi r27, 0x20 ; 32
64c: eb 9f mul r30, r27
64e: f0 01 movw r30, r0
650: 11 24 eor r1, r1
652: fc 5f subi r31, 0xFC ; 252
654: 61 11 cpse r22, r1
656: 36 c0 rjmp .+108 ; 0x6c4 <digitalWrite+0x9e>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:255
/* Set output to value
This runs regardless of whether the pin is an output,
allowing the pin to be staged with
changed to an output. Code in the wild relies on this behavior. */
if (val == LOW) { /* If LOW */
658: 26 83 std Z+6, r18 ; 0x06
65a: 30 81 ld r19, Z
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:256
port->OUTCLR = bit_mask;
65c: 23 23 and r18, r19
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:280
} else {
port->OUTSET = bit_mask;
}
/* Input direction */
if (!(port->DIR & bit_mask)) {
65e: a1 f4 brne .+40 ; 0x688 <digitalWrite+0x62>
660: 9c 01 movw r18, r24
662: 25 5b subi r18, 0xB5 ; 181
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:282
/* Get bit position for getting pin ctrl reg */
uint8_t bit_pos = digitalPinToBitPosition(pin);
664: 3f 46 sbci r19, 0x6F ; 111
666: d9 01 movw r26, r18
668: 2c 91 ld r18, X
66a: 30 97 sbiw r30, 0x00 ; 0
66c: 69 f1 breq .+90 ; 0x6c8 <digitalWrite+0xa2>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:284
/* Calculate where pin control register is */
volatile uint8_t *pin_ctrl_reg = getPINnCTRLregister(port, bit_pos);
66e: 28 30 cpi r18, 0x08 ; 8
670: 58 f5 brcc .+86 ; 0x6c8 <digitalWrite+0xa2>
672: 70 96 adiw r30, 0x10 ; 16
674: e2 0f add r30, r18
676: f1 1d adc r31, r1
678: 3f b7 in r19, 0x3f ; 63
67a: f8 94 cli
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:287
/* Save system status and disable interrupts */
uint8_t status = SREG;
67c: 20 81 ld r18, Z
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:288
cli();
67e: 61 11 cpse r22, r1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:292
if (val == LOW) {
/* Disable pullup */
*pin_ctrl_reg &= ~PORT_PULLUPEN_bm;
680: 26 c0 rjmp .+76 ; 0x6ce <digitalWrite+0xa8>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:290
/* Save system status and disable interrupts */
uint8_t status = SREG;
cli();
if (val == LOW) {
682: 27 7f andi r18, 0xF7 ; 247
684: 20 83 st Z, r18
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:292
/* Disable pullup */
*pin_ctrl_reg &= ~PORT_PULLUPEN_bm;
686: 3f bf out 0x3f, r19 ; 63
turnOffPWM():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:295
} else {
/* Enable pull-up */
*pin_ctrl_reg |= PORT_PULLUPEN_bm;
688: 87 5c subi r24, 0xC7 ; 199
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:299
}
/* Restore system status */
SREG = status;
68a: 9f 46 sbci r25, 0x6F ; 111
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:107
* any timers with minimum overhead - critical on these parts
* Since nothing that will show up here can have more than one
* one bit set, binary and will give 0x00 if that bit is cleared
* which is NOT_ON_TIMER.
*/
uint8_t digital_pin_timer = digitalPinToTimer(pin) & __PeripheralControl;
68c: fc 01 movw r30, r24
68e: 90 81 ld r25, Z
690: 99 23 and r25, r25
692: a9 f0 breq .+42 ; 0x6be <digitalWrite+0x98>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:109
/* end megaTinyCore-specific section */
if (digital_pin_timer== NOT_ON_TIMER) {
694: 88 81 ld r24, Y
696: 90 34 cpi r25, 0x40 ; 64
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:113
return;
}
uint8_t bit_mask = digitalPinToBitMask(pin);
698: 09 f1 breq .+66 ; 0x6dc <digitalWrite+0xb6>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:116
// TCB_t *timerB;
switch (digital_pin_timer) {
69a: 98 3f cpi r25, 0xF8 ; 248
69c: e1 f0 breq .+56 ; 0x6d6 <digitalWrite+0xb0>
69e: 90 31 cpi r25, 0x10 ; 16
6a0: 71 f4 brne .+28 ; 0x6be <digitalWrite+0x98>
6a2: da 01 movw r26, r20
6a4: 9c 91 ld r25, X
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:132
}
if (bit_mask > 0x04) { // -> bit_pos > 2 -> output channel controlled by HCMP
bit_mask <<= 1; // mind the gap (between LCMP and HCMP)
}
#else // Normal parts
if (digitalPinToPort(pin) == PB) { // WO0-WO2, Bitmask has one of these bits 1: 0b00hhhlll.
6a6: 91 30 cpi r25, 0x01 ; 1
6a8: a1 f4 brne .+40 ; 0x6d2 <digitalWrite+0xac>
6aa: 85 30 cpi r24, 0x05 ; 5
6ac: 10 f0 brcs .+4 ; 0x6b2 <digitalWrite+0x8c>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:133
if (bit_mask > 0x04) { // Is it one of the three high ones? If so
6ae: 88 0f add r24, r24
6b0: 82 95 swap r24
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:134
bit_mask <<= 1; // nudge it 1 place left swap nybbles since that's 1 clock faster than 3 rightshifts.
6b2: 90 91 01 0a lds r25, 0x0A01 ; 0x800a01 <digital_pin_to_bit_mask+0x7f7992>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:142
} else {
// Otherwise, it's WO3-5. These will always be on 0b00hhh000,. Here since we ARE working with a high half timer, we need to just leftshift it once.
bit_mask <<= 1;
}
#endif // End if 8 vs normal parts
TCA0.SPLIT.CTRLB &= ~bit_mask;
6b6: 80 95 com r24
6b8: 89 23 and r24, r25
6ba: 80 93 01 0a sts 0x0A01, r24 ; 0x800a01 <digital_pin_to_bit_mask+0x7f7992>
digitalWrite():
6be: df 91 pop r29
6c0: cf 91 pop r28
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:312
* analogWritten() 255, then digitallyWritten() to HIGH, which
* would turn it off for the time between turnOffPWM() and
* PORT->OUTCLR)
* Since there's no penalty, why make a glitch we don't have to? */
turnOffPWM(pin);
}
6c2: 08 95 ret
6c4: 25 83 std Z+5, r18 ; 0x05
6c6: c9 cf rjmp .-110 ; 0x65a <digitalWrite+0x34>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:276
// val will now be 0 (LOW) if the toggling made it LOW
// or bit_mask if not. And further down, we only need to
// know if it's
/* If HIGH OR > TOGGLE */
} else {
port->OUTSET = bit_mask;
6c8: f0 e0 ldi r31, 0x00 ; 0
6ca: e0 e0 ldi r30, 0x00 ; 0
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:284
/* Input direction */
if (!(port->DIR & bit_mask)) {
/* Get bit position for getting pin ctrl reg */
uint8_t bit_pos = digitalPinToBitPosition(pin);
/* Calculate where pin control register is */
volatile uint8_t *pin_ctrl_reg = getPINnCTRLregister(port, bit_pos);
6cc: d5 cf rjmp .-86 ; 0x678 <digitalWrite+0x52>
6ce: 28 60 ori r18, 0x08 ; 8
6d0: d9 cf rjmp .-78 ; 0x684 <digitalWrite+0x5e>
turnOffPWM():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:295
if (val == LOW) {
/* Disable pullup */
*pin_ctrl_reg &= ~PORT_PULLUPEN_bm;
} else {
/* Enable pull-up */
*pin_ctrl_reg |= PORT_PULLUPEN_bm;
6d2: 88 0f add r24, r24
6d4: ee cf rjmp .-36 ; 0x6b2 <digitalWrite+0x8c>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:139
bit_mask <<= 1; // nudge it 1 place left swap nybbles since that's 1 clock faster than 3 rightshifts.
_SWAP(bit_mask); // swap nybbles since that's 1 clock faster than 3 rightshifts.
}
} else {
// Otherwise, it's WO3-5. These will always be on 0b00hhh000,. Here since we ARE working with a high half timer, we need to just leftshift it once.
bit_mask <<= 1;
6d6: 10 92 a0 06 sts 0x06A0, r1 ; 0x8006a0 <digital_pin_to_bit_mask+0x7f7631>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:161
/* We don't need the type b timers as this core does not use them for PWM */
// 1-series parts have a DAC that we can use...
#if defined(DAC0)
case DACOUT:
DAC0.CTRLA = 0x00;
6da: f1 cf rjmp .-30 ; 0x6be <digitalWrite+0x98>
6dc: 82 30 cpi r24, 0x02 ; 2
6de: 19 f1 breq .+70 ; 0x726 <digitalWrite+0x100>
digitalWrite():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:197
#endif
SREG = oldSREG;
}
#else
uint8_t fc_mask = (bit_mask == 0x02 ? 0x80 : 0x40);
6e0: 80 e4 ldi r24, 0x40 ; 64
turnOffPWM():
6e2: 90 91 92 0a lds r25, 0x0A92 ; 0x800a92 <digital_pin_to_bit_mask+0x7f7a23>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:198
if (TCD0.FAULTCTRL & fc_mask) {
6e6: 98 23 and r25, r24
6e8: 51 f3 breq .-44 ; 0x6be <digitalWrite+0x98>
6ea: 4f b7 in r20, 0x3f ; 63
6ec: f8 94 cli
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:199
uint8_t oldSREG = SREG;
6ee: 90 91 80 0a lds r25, 0x0A80 ; 0x800a80 <digital_pin_to_bit_mask+0x7f7a11>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:203
cli();
// uint8_t TCD0_prescaler=TCD0.CTRLA & (~TCD_ENABLE_bm);
//
TCD0.CTRLA &= ~TCD_ENABLE_bm;
6f2: 9e 7f andi r25, 0xFE ; 254
6f4: 90 93 80 0a sts 0x0A80, r25 ; 0x800a80 <digital_pin_to_bit_mask+0x7f7a11>
6f8: 20 91 92 0a lds r18, 0x0A92 ; 0x800a92 <digital_pin_to_bit_mask+0x7f7a23>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:204
_PROTECTED_WRITE(TCD0.FAULTCTRL, TCD0.FAULTCTRL & (~fc_mask));
6fc: 90 e0 ldi r25, 0x00 ; 0
6fe: 80 95 com r24
700: 90 95 com r25
702: 30 e0 ldi r19, 0x00 ; 0
704: 82 23 and r24, r18
706: 93 23 and r25, r19
708: 28 ed ldi r18, 0xD8 ; 216
70a: 24 bf out 0x34, r18 ; 52
70c: 80 93 92 0a sts 0x0A92, r24 ; 0x800a92 <digital_pin_to_bit_mask+0x7f7a23>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:205
while (!(TCD0.STATUS & TCD_ENRDY_bm));
710: 80 91 8e 0a lds r24, 0x0A8E ; 0x800a8e <digital_pin_to_bit_mask+0x7f7a1f>
714: 80 ff sbrs r24, 0
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:206
TCD0.CTRLA |= TCD_ENABLE_bm;
716: fc cf rjmp .-8 ; 0x710 <digitalWrite+0xea>
718: 80 91 80 0a lds r24, 0x0A80 ; 0x800a80 <digital_pin_to_bit_mask+0x7f7a11>
71c: 81 60 ori r24, 0x01 ; 1
71e: 80 93 80 0a sts 0x0A80, r24 ; 0x800a80 <digital_pin_to_bit_mask+0x7f7a11>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:228
} else {
PORTC.PIN1CTRL &= ~(PORT_INVEN_bm);
}
#endif
#endif
SREG = oldSREG;
722: 4f bf out 0x3f, r20 ; 63
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:197
#endif
SREG = oldSREG;
}
#else
uint8_t fc_mask = (bit_mask == 0x02 ? 0x80 : 0x40);
724: cc cf rjmp .-104 ; 0x6be <digitalWrite+0x98>
digitalWrite():
726: 80 e8 ldi r24, 0x80 ; 128
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:33
constexpr float STRING_HZ[] = { 82.4069f, 110.0f, 146.832f, 195.998f, 246.942f, 329.628f };
constexpr float IN_TUNE_CENTS = 4.0f;
int16_t samples[SAMPLE_COUNT];
void allLedsOff() {
728: dc cf rjmp .-72 ; 0x6e2 <digitalWrite+0xbc>
0000072a <allLedsOff()>:
_Z10allLedsOffv():
72a: cf 93 push r28
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:34
for (uint8_t pin : NOTE_LEDS) digitalWrite(pin, LOW);
72c: df 93 push r29
72e: c3 e3 ldi r28, 0x33 ; 51
730: d0 e9 ldi r29, 0x90 ; 144
732: 60 e0 ldi r22, 0x00 ; 0
734: 89 91 ld r24, Y+
736: 77 df rcall .-274 ; 0x626 <digitalWrite>
738: 80 e9 ldi r24, 0x90 ; 144
73a: c9 33 cpi r28, 0x39 ; 57
73c: d8 07 cpc r29, r24
73e: c9 f7 brne .-14 ; 0x732 <allLedsOff()+0x8>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:35
digitalWrite(FLAT_LED, LOW);
740: 60 e0 ldi r22, 0x00 ; 0
742: 86 e0 ldi r24, 0x06 ; 6
744: 70 df rcall .-288 ; 0x626 <digitalWrite>
746: 60 e0 ldi r22, 0x00 ; 0
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:36
digitalWrite(TUNE_LED, LOW);
748: 88 e0 ldi r24, 0x08 ; 8
74a: 6d df rcall .-294 ; 0x626 <digitalWrite>
74c: 60 e0 ldi r22, 0x00 ; 0
74e: 87 e0 ldi r24, 0x07 ; 7
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:37
digitalWrite(SHARP_LED, LOW);
750: df 91 pop r29
752: cf 91 pop r28
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:38
}
754: 68 cf rjmp .-304 ; 0x626 <digitalWrite>
00000756 <pinMode>:
pinMode():
756: 82 31 cpi r24, 0x12 ; 18
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:37
void allLedsOff() {
for (uint8_t pin : NOTE_LEDS) digitalWrite(pin, LOW);
digitalWrite(FLAT_LED, LOW);
digitalWrite(TUNE_LED, LOW);
digitalWrite(SHARP_LED, LOW);
758: f0 f4 brcc .+60 ; 0x796 <pinMode+0x40>
check_valid_digital_pin():
75a: 90 e0 ldi r25, 0x00 ; 0
pinMode():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:44
}
void pinMode(uint8_t pin, uint8_t mode) {
check_valid_digital_pin(pin); /* generate compile error if a constant that is not a valid pin is used as the pin */
check_valid_pin_mode(mode); /* generate compile error if a constant that is not a valid pin mode is used as the mode */
uint8_t bit_mask = digitalPinToBitMask(pin);
75c: fc 01 movw r30, r24
75e: e1 59 subi r30, 0x91 ; 145
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/Arduino.h:888
760: ff 46 sbci r31, 0x6F ; 111
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:44
762: 20 81 ld r18, Z
764: 2f 3f cpi r18, 0xFF ; 255
766: b9 f0 breq .+46 ; 0x796 <pinMode+0x40>
768: fc 01 movw r30, r24
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:45
if ((bit_mask == NOT_A_PIN) || (mode > INPUT_PULLUP)) {
76a: e3 5a subi r30, 0xA3 ; 163
76c: ff 46 sbci r31, 0x6F ; 111
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:48
return; /* ignore invalid pins passed at runtime */
}
volatile uint8_t * port_base = (volatile uint8_t *) (uint16_t) ((&PORTA) + digitalPinToPort(pin));
76e: e0 81 ld r30, Z
770: 30 e2 ldi r19, 0x20 ; 32
772: e3 9f mul r30, r19
774: f0 01 movw r30, r0
776: 11 24 eor r1, r1
778: fc 5f subi r31, 0xFC ; 252
77a: 60 ff sbrs r22, 0
77c: 0d c0 rjmp .+26 ; 0x798 <pinMode+0x42>
77e: 21 83 std Z+1, r18 ; 0x01
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:49
if (mode & 0x01) {
780: 85 5b subi r24, 0xB5 ; 181
782: 9f 46 sbci r25, 0x6F ; 111
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:51
// OUTPUT mode, so write DIRSET with the mask.
*(port_base + 1) = bit_mask;
784: dc 01 movw r26, r24
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:77
// then load with displacement 2 clocks. IFF the compiler puts this pointer into Y or Z, it is faster and smaller
// by 2 bytes and one clock. And let's hope it is, because the code above would suck too if it was in X.
// Handwritten assembly that exploited the knowledge that there will never be a carry would save 1 word and 1 clock.
// and could probably save at least several times that in initializing the port_base pointer. But if you're using
// pinMode you probably don't care.
port_base += (uint8_t) digitalPinToBitPosition(pin);
786: 8c 91 ld r24, X
788: e8 0f add r30, r24
78a: f1 1d adc r31, r1
78c: 80 89 ldd r24, Z+16 ; 0x10
78e: 61 ff sbrs r22, 1
790: 05 c0 rjmp .+10 ; 0x79c <pinMode+0x46>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:78
bit_mask = *(port_base + 0x10);
792: 88 60 ori r24, 0x08 ; 8
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:79
if (mode & 2) {
794: 80 8b std Z+16, r24 ; 0x10
796: 08 95 ret
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:80
bit_mask |= 0x08;
798: 22 83 std Z+2, r18 ; 0x02
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:84
} else {
bit_mask &= 0xF7;
}
*(port_base + 0x10) = bit_mask;
79a: f2 cf rjmp .-28 ; 0x780 <pinMode+0x2a>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:85
}
79c: 87 7f andi r24, 0xF7 ; 247
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:53
volatile uint8_t * port_base = (volatile uint8_t *) (uint16_t) ((&PORTA) + digitalPinToPort(pin));
if (mode & 0x01) {
// OUTPUT mode, so write DIRSET with the mask.
*(port_base + 1) = bit_mask;
} else { // otherwise it's input so we write DIRCLR
*(port_base + 2) = bit_mask;
79e: fa cf rjmp .-12 ; 0x794 <pinMode+0x3e>
000007a0 <__vector_15>:
__vector_15():
7a0: 8f 93 push r24
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_digital.c:82
port_base += (uint8_t) digitalPinToBitPosition(pin);
bit_mask = *(port_base + 0x10);
if (mode & 2) {
bit_mask |= 0x08;
} else {
bit_mask &= 0xF7;
7a2: 81 e0 ldi r24, 0x01 ; 1
7a4: 80 93 8d 0a sts 0x0A8D, r24 ; 0x800a8d <digital_pin_to_bit_mask+0x7f7a1e>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:839
#else
ISR(MILLIS_TIMER_VECTOR, ISR_NAKED) {
// Common Interrupt header for TCB, TCA and TCD;
// Clears the Timer Interrupt flag and pushes the CPU Registers
// 7 words / 7 clocks
__asm__ __volatile__(
7a8: 8f b7 in r24, 0x3f ; 63
7aa: 8f 93 push r24
7ac: ef 93 push r30
7ae: ff 93 push r31
7b0: e0 e0 ldi r30, 0x00 ; 0
7b2: f8 e3 ldi r31, 0x38 ; 56
7b4: 9f 93 push r25
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:950
[MIINC] "M" ((0x0000 - MILLIS_INC) & 0xFF),
[MINCD] "M" ((0xFFFF - MILLIS_INC) & 0xFF)
);
*/
__asm__ __volatile__(
7b6: 68 94 set
7b8: 8f ef ldi r24, 0xFF ; 255
7ba: 0d c0 rjmp .+26 ; 0x7d6 <sub4>
000007bc <ovf_end>:
7bc: e8 94 clt
7be: 84 81 ldd r24, Z+4 ; 0x04
7c0: 95 81 ldd r25, Z+5 ; 0x05
7c2: 80 5d subi r24, 0xD0 ; 208
7c4: 9c 4f sbci r25, 0xFC ; 252
7c6: 84 83 std Z+4, r24 ; 0x04
7c8: 95 83 std Z+5, r25 ; 0x05
7ca: 88 5e subi r24, 0xE8 ; 232
7cc: 93 40 sbci r25, 0x03 ; 3
7ce: 80 f0 brcs .+32 ; 0x7f0 <sub_end>
7d0: 84 83 std Z+4, r24 ; 0x04
7d2: 95 83 std Z+5, r25 ; 0x05
7d4: 8f ef ldi r24, 0xFF ; 255
000007d6 <sub4>:
7d6: 90 81 ld r25, Z
7d8: 98 1b sub r25, r24
7da: 91 93 st Z+, r25
7dc: 90 81 ld r25, Z
7de: 9f 4f sbci r25, 0xFF ; 255
7e0: 91 93 st Z+, r25
7e2: 90 81 ld r25, Z
7e4: 9f 4f sbci r25, 0xFF ; 255
7e6: 91 93 st Z+, r25
7e8: 90 81 ld r25, Z
7ea: 9f 4f sbci r25, 0xFF ; 255
7ec: 91 93 st Z+, r25
7ee: 36 f3 brts .-52 ; 0x7bc <ovf_end>
000007f0 <sub_end>:
7f0: 9f 91 pop r25
7f2: ff 91 pop r31
7f4: ef 91 pop r30
7f6: 8f 91 pop r24
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_micros_ISR.h:1012
[MINCD] "M" ((0xFFFF - MILLIS_INC) & 0xFF)
);
#endif /* (defined(MILLIS_USE_TIMERB0) || defined(MILLIS_USE_TIMERB1) || defined(MILLIS_USE_TIMERB2) || defined(MILLIS_USE_TIMERB3) || defined(MILLIS_USE_TIMERB4)) */
// Common ISR Epilogue for TCA, TCB and TCD, popping register in reverse Order
// 6 words, 14 clocks
__asm__ __volatile__(
7f8: 8f bf out 0x3f, r24 ; 63
7fa: 8f 91 pop r24
7fc: 18 95 reti
000007fe <main>:
main():
7fe: cf 93 push r28
800: df 93 push r29
802: cd b7 in r28, 0x3d ; 61
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/main.cpp:49
* called first in non-optiboot configurations (neither is needed on Optibooot configurations() *
* an extra bit of initialization code in .init3 to fix the vectors and still happen if user *
* overrides main. In the past there was a USB-related function here, that is removed, as work *
* will be needed in any event at the core level if VUSB-based "stuff" arrives, but really I'm *
* just waiting for the DU-series now */
int main() {
804: de b7 in r29, 0x3e ; 62
806: 2b 97 sbiw r28, 0x0b ; 11
808: cd bf out 0x3d, r28 ; 61
80a: de bf out 0x3e, r29 ; 62
init_clock():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:460
#if (CLOCK_SOURCE == 0)
#if (defined(CLOCK_TUNE_INTERNAL))
tune_internal(); // Will be inlined as only called once. Just too long and ugly to put two implementations in middle of this.
#else
#if defined(_MCLK_CTRLB) && defined(F_CPU) && defined(_MAIN_CLOCK_PRESCALER)
_PROTECTED_WRITE(CLKCTRL_MCLKCTRLB,_MCLK_CTRLB);
80c: 81 e0 ldi r24, 0x01 ; 1
80e: 98 ed ldi r25, 0xD8 ; 216
810: 94 bf out 0x34, r25 ; 52
812: 80 93 61 00 sts 0x0061, r24 ; 0x800061 <digital_pin_to_bit_mask+0x7f6ff2>
init_ADC0():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:552
/********************************* ADC ****************************************/
void __attribute__((weak)) init_ADC0() {
ADC_t* pADC;
_fastPtr_d(pADC, &ADC0);
816: e0 e0 ldi r30, 0x00 ; 0
818: f6 e0 ldi r31, 0x06 ; 6
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:575
#if F_CPU > 24000000 // 24 MHz / 16 = 1.5 MHz, 25 MHz / 32 = 780 kHz
pADC->CTRLC = ADC_PRESC_DIV32_gc | ADC_REFSEL_VDDREF_gc | ADC_SAMPCAP_bm;
#elif F_CPU >= 12000000 // 16 MHz / 16 = 1.0 MHz, 20 MHz / 16 = 1.25 MHz
pADC->CTRLC = ADC_PRESC_DIV16_gc | ADC_REFSEL_VDDREF_gc | ADC_SAMPCAP_bm;
#elif F_CPU >= 6000000 // 8 MHz / 8 = 1.0 MHz, 10 MHz / 8 = 1.25 MHz
pADC->CTRLC = ADC_PRESC_DIV8_gc | ADC_REFSEL_VDDREF_gc | ADC_SAMPCAP_bm;
81a: 92 e5 ldi r25, 0x52 ; 82
81c: 92 83 std Z+2, r25 ; 0x02
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:584
pADC->CTRLC = ADC_PRESC_DIV2_gc | ADC_REFSEL_VDDREF_gc | ADC_SAMPCAP_bm;
#endif
#if (F_CPU == 6000000 || F_CPU == 12000000 || F_CPU == 24000000 || F_CPU ==25000000)
pADC->SAMPCTRL = (7); // 9 ADC clocks, 12 us
#elif (F_CPU == 5000000 || F_CPU == 10000000 || F_CPU == 20000000)
pADC->SAMPCTRL = (13); // 15 ADC clock,s 12 us
81e: 9d e0 ldi r25, 0x0D ; 13
820: 95 83 std Z+5, r25 ; 0x05
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:588
#else
pADC->SAMPCTRL = (10); // 12 ADC clocks, 12 us
#endif
pADC->CTRLD = ADC_INITDLY_DLY16_gc;
822: 90 e2 ldi r25, 0x20 ; 32
824: 93 83 std Z+3, r25 ; 0x03
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:589
pADC->CTRLA = ADC_ENABLE_bm;
826: 80 83 st Z, r24
init_TCA0():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:680
void __attribute__((weak)) init_TCA0() {
/* TYPE A TIMER */
#if !defined(TCA_BUFFERED_3PIN)
#if defined(PORTMUX_CTRLC)
PORTMUX.CTRLC = TCA_PORTMUX;
828: 10 92 02 02 sts 0x0202, r1 ; 0x800202 <digital_pin_to_bit_mask+0x7f7193>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:684
#else
PORTMUX.TCAROUTEA = TCA_PORTMUX;
#endif
TCA0.SPLIT.CTRLD = TCA_SPLIT_SPLITM_bm;
82c: 80 93 03 0a sts 0x0A03, r24 ; 0x800a03 <digital_pin_to_bit_mask+0x7f7994>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:685
TCA0.SPLIT.LPER = PWM_TIMER_PERIOD;
830: 9e ef ldi r25, 0xFE ; 254
832: 90 93 26 0a sts 0x0A26, r25 ; 0x800a26 <digital_pin_to_bit_mask+0x7f79b7>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:686
TCA0.SPLIT.HPER = PWM_TIMER_PERIOD;
836: 90 93 27 0a sts 0x0A27, r25 ; 0x800a27 <digital_pin_to_bit_mask+0x7f79b8>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:687
TCA0.SPLIT.CTRLA = (_TIMERA_PRESCALER | TCA_SPLIT_ENABLE_bm);
83a: 9b e0 ldi r25, 0x0B ; 11
83c: 90 93 00 0a sts 0x0A00, r25 ; 0x800a00 <digital_pin_to_bit_mask+0x7f7991>
init_millis():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:345
#else
TCA0.SINGLE.INTCTRL = TCA_SINGLE_OVF_bm;
#endif
#elif defined(MILLIS_USE_TIMERD0)
TCD_t* pTCD;
_fastPtr_d(pTCD, &TCD0);
840: e0 e8 ldi r30, 0x80 ; 128
842: fa e0 ldi r31, 0x0A ; 10
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:346
pTCD->CMPBCLR = TIME_TRACKING_TIMER_PERIOD; // essentially, this is TOP
844: 2d ef ldi r18, 0xFD ; 253
846: 31 e0 ldi r19, 0x01 ; 1
848: 26 a7 std Z+46, r18 ; 0x2e
84a: 37 a7 std Z+47, r19 ; 0x2f
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:347
pTCD->CTRLB = 0x00; // oneramp mode
84c: 11 82 std Z+1, r1 ; 0x01
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:348
pTCD->CTRLC = 0x80;
84e: 90 e8 ldi r25, 0x80 ; 128
850: 92 83 std Z+2, r25 ; 0x02
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:349
pTCD->INTCTRL = 0x01; // enable interrupt
852: 84 87 std Z+12, r24 ; 0x0c
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring.c:350
pTCD->CTRLA = _TIMERD0_PRESCALER | 0x01; // set clock source and enable!
854: 81 e1 ldi r24, 0x11 ; 17
856: 80 83 st Z, r24
main():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/main.cpp:53
onBeforeInit(); // Emnpty callback called before init but after the .init stuff. First normal code executed
init(); // Interrupts are turned on just prior to init() returning.
initVariant();
if (!onAfterInit()) sei(); // enable interrupts.
858: 78 94 sei
analogReadResolution():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_analog.c:141
#else
if (res == 8) {
ADC0.CTRLA |= ADC_RESSEL_bm;
return true;
}
ADC0.CTRLA &= ~ADC_RESSEL_bm;
85a: 80 91 00 06 lds r24, 0x0600 ; 0x800600 <digital_pin_to_bit_mask+0x7f7591>
85e: 8b 7f andi r24, 0xFB ; 251
860: 80 93 00 06 sts 0x0600, r24 ; 0x800600 <digital_pin_to_bit_mask+0x7f7591>
setup():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:86
else digitalWrite(TUNE_LED, HIGH);
}
void setup() {
analogReadResolution(10);
pinMode(AUDIO_PIN, INPUT);
864: 60 e0 ldi r22, 0x00 ; 0
866: 8f e0 ldi r24, 0x0F ; 15
868: 76 df rcall .-276 ; 0x756 <pinMode>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:87
pinMode(MODE_PIN, INPUT_PULLUP);
86a: 62 e0 ldi r22, 0x02 ; 2
86c: 89 e0 ldi r24, 0x09 ; 9
86e: 73 df rcall .-282 ; 0x756 <pinMode>
main():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:88
for (uint8_t pin : NOTE_LEDS) pinMode(pin, OUTPUT);
870: 03 e3 ldi r16, 0x33 ; 51
872: 10 e9 ldi r17, 0x90 ; 144
setup():
874: 61 e0 ldi r22, 0x01 ; 1
876: f8 01 movw r30, r16
878: 81 91 ld r24, Z+
87a: 8f 01 movw r16, r30
87c: 6c df rcall .-296 ; 0x756 <pinMode>
87e: f0 e9 ldi r31, 0x90 ; 144
880: 09 33 cpi r16, 0x39 ; 57
882: 1f 07 cpc r17, r31
884: b9 f7 brne .-18 ; 0x874 <__DATA_REGION_LENGTH__+0x74>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:89
pinMode(FLAT_LED, OUTPUT);
886: 61 e0 ldi r22, 0x01 ; 1
888: 86 e0 ldi r24, 0x06 ; 6
88a: 65 df rcall .-310 ; 0x756 <pinMode>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:90
pinMode(TUNE_LED, OUTPUT);
88c: 61 e0 ldi r22, 0x01 ; 1
88e: 88 e0 ldi r24, 0x08 ; 8
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:91
pinMode(SHARP_LED, OUTPUT);
890: 62 df rcall .-316 ; 0x756 <pinMode>
892: 61 e0 ldi r22, 0x01 ; 1
894: 87 e0 ldi r24, 0x07 ; 7
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:92
allLedsOff();
896: 5f df rcall .-322 ; 0x756 <pinMode>
898: 48 df rcall .-368 ; 0x72a <allLedsOff()>
loop():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:102
// Sequence one LED at a time to avoid a nine-LED current pulse on CR2032.
const uint8_t indicators[] = {NOTE_LEDS[0], NOTE_LEDS[1], NOTE_LEDS[2],
NOTE_LEDS[3], NOTE_LEDS[4], NOTE_LEDS[5], FLAT_LED, TUNE_LED, SHARP_LED};
allLedsOff();
do {
for (uint8_t pin : indicators) {
89a: 1e 01 movw r2, r28
89c: 8a e0 ldi r24, 0x0A ; 10
89e: 28 0e add r2, r24
8a0: 31 1c adc r3, r1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:96
pinMode(SHARP_LED, OUTPUT);
allLedsOff();
}
void loop() {
if (digitalRead(MODE_PIN) == LOW) {
8a2: bd de rcall .-646 ; 0x61e <digitalRead.constprop.2>
8a4: 81 11 cpse r24, r1
8a6: 28 c0 rjmp .+80 ; 0x8f8 <__DATA_REGION_LENGTH__+0xf8>
8a8: 89 e0 ldi r24, 0x09 ; 9
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:98
// Sequence one LED at a time to avoid a nine-LED current pulse on CR2032.
const uint8_t indicators[] = {NOTE_LEDS[0], NOTE_LEDS[1], NOTE_LEDS[2],
8aa: e2 e1 ldi r30, 0x12 ; 18
8ac: f0 e9 ldi r31, 0x90 ; 144
8ae: de 01 movw r26, r28
8b0: 11 96 adiw r26, 0x01 ; 1
8b2: 01 90 ld r0, Z+
8b4: 0d 92 st X+, r0
8b6: 8a 95 dec r24
8b8: e1 f7 brne .-8 ; 0x8b2 <__DATA_REGION_LENGTH__+0xb2>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:100
NOTE_LEDS[3], NOTE_LEDS[4], NOTE_LEDS[5], FLAT_LED, TUNE_LED, SHARP_LED};
allLedsOff();
8ba: 37 df rcall .-402 ; 0x72a <allLedsOff()>
main():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:102
do {
for (uint8_t pin : indicators) {
8bc: 8e 01 movw r16, r28
8be: 0f 5f subi r16, 0xFF ; 255
8c0: 1f 4f sbci r17, 0xFF ; 255
loop():
8c2: f8 01 movw r30, r16
8c4: f1 90 ld r15, Z+
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:103
digitalWrite(pin, HIGH);
8c6: 8f 01 movw r16, r30
8c8: 61 e0 ldi r22, 0x01 ; 1
8ca: 8f 2d mov r24, r15
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:104
delay(150);
8cc: ac de rcall .-680 ; 0x626 <digitalWrite>
8ce: 66 e9 ldi r22, 0x96 ; 150
8d0: 70 e0 ldi r23, 0x00 ; 0
8d2: 80 e0 ldi r24, 0x00 ; 0
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:105
digitalWrite(pin, LOW);
8d4: 90 e0 ldi r25, 0x00 ; 0
8d6: 79 de rcall .-782 ; 0x5ca <delay>
8d8: 60 e0 ldi r22, 0x00 ; 0
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:102
// Sequence one LED at a time to avoid a nine-LED current pulse on CR2032.
const uint8_t indicators[] = {NOTE_LEDS[0], NOTE_LEDS[1], NOTE_LEDS[2],
NOTE_LEDS[3], NOTE_LEDS[4], NOTE_LEDS[5], FLAT_LED, TUNE_LED, SHARP_LED};
allLedsOff();
do {
for (uint8_t pin : indicators) {
8da: 8f 2d mov r24, r15
8dc: a4 de rcall .-696 ; 0x626 <digitalWrite>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:107
digitalWrite(pin, HIGH);
delay(150);
digitalWrite(pin, LOW);
}
} while (digitalRead(MODE_PIN) == LOW);
8de: 02 15 cp r16, r2
8e0: 13 05 cpc r17, r3
8e2: 79 f7 brne .-34 ; 0x8c2 <__DATA_REGION_LENGTH__+0xc2>
8e4: 9c de rcall .-712 ; 0x61e <digitalRead.constprop.2>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:108
allLedsOff();
8e6: 88 23 and r24, r24
8e8: 49 f3 breq .-46 ; 0x8bc <__DATA_REGION_LENGTH__+0xbc>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:109
delay(100);
8ea: 1f df rcall .-450 ; 0x72a <allLedsOff()>
8ec: 64 e6 ldi r22, 0x64 ; 100
8ee: 70 e0 ldi r23, 0x00 ; 0
8f0: 80 e0 ldi r24, 0x00 ; 0
8f2: 90 e0 ldi r25, 0x00 ; 0
8f4: 6a de rcall .-812 ; 0x5ca <delay>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:41
digitalWrite(TUNE_LED, LOW);
digitalWrite(SHARP_LED, LOW);
}
void captureSamples() {
uint32_t next = micros();
8f6: d5 cf rjmp .-86 ; 0x8a2 <__DATA_REGION_LENGTH__+0xa2>
captureSamples():
8f8: 18 de rcall .-976 ; 0x52a <micros>
8fa: 2b 01 movw r4, r22
8fc: 3c 01 movw r6, r24
8fe: 0a e0 ldi r16, 0x0A ; 10
900: 18 e3 ldi r17, 0x38 ; 56
902: 58 01 movw r10, r16
main():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:42
int32_t sum = 0;
904: c1 2c mov r12, r1
906: d1 2c mov r13, r1
908: 76 01 movw r14, r12
captureSamples():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:44
for (uint16_t i = 0; i < SAMPLE_COUNT; ++i) {
while ((int32_t)(micros() - next) < 0) {}
90a: 0f de rcall .-994 ; 0x52a <micros>
90c: 64 19 sub r22, r4
90e: 75 09 sbc r23, r5
910: 86 09 sbc r24, r6
912: 97 09 sbc r25, r7
914: 97 fd sbrc r25, 7
916: f9 cf rjmp .-14 ; 0x90a <__DATA_REGION_LENGTH__+0x10a>
analogRead():
918: 80 91 00 06 lds r24, 0x0600 ; 0x800600 <digital_pin_to_bit_mask+0x7f7591>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_analog.c:716
// don't waste flash on smallest parts.
if ((pin & 0x7F) > 0x1F) { // highest valid mux value for any 0 or 1-series part.
return ADC_ERROR_BAD_PIN_OR_CHANNEL;
}
#endif
if (!ADC0.CTRLA & 0x01) return ADC_ERROR_DISABLED;
91c: 88 23 and r24, r24
91e: 09 f4 brne .+2 ; 0x922 <__DATA_REGION_LENGTH__+0x122>
920: a0 c0 rjmp .+320 ; 0xa62 <__DATA_REGION_LENGTH__+0x262>
922: f2 e0 ldi r31, 0x02 ; 2
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_analog.c:720
pin &= 0x1F;
/* Reference should be already set up */
/* Select channel */
ADC0.MUXPOS = (pin << ADC_MUXPOS_gp);
924: f0 93 06 06 sts 0x0606, r31 ; 0x800606 <digital_pin_to_bit_mask+0x7f7597>
928: 81 e0 ldi r24, 0x01 ; 1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_analog.c:727
#if defined(STRICT_ERROR_CHECKING)
if (ADC0.COMMAND) return ADC_ERROR_BUSY;
#endif
/* Start conversion */
ADC0.COMMAND = ADC_STCONV_bm;
92a: 80 93 08 06 sts 0x0608, r24 ; 0x800608 <digital_pin_to_bit_mask+0x7f7599>
92e: 80 91 0b 06 lds r24, 0x060B ; 0x80060b <digital_pin_to_bit_mask+0x7f759c>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_analog.c:730
/* Wait for result ready */
while (!(ADC0.INTFLAGS & ADC_RESRDY_bm));
932: 80 ff sbrs r24, 0
934: fc cf rjmp .-8 ; 0x92e <__DATA_REGION_LENGTH__+0x12e>
936: 80 91 10 06 lds r24, 0x0610 ; 0x800610 <digital_pin_to_bit_mask+0x7f75a1>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_analog.c:733
/* Combine two bytes */
return ADC0.RES;
93a: 90 91 11 06 lds r25, 0x0611 ; 0x800611 <digital_pin_to_bit_mask+0x7f75a2>
captureSamples():
93e: f5 01 movw r30, r10
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:46
const int16_t value = analogRead(AUDIO_PIN);
samples[i] = value;
940: 81 93 st Z+, r24
942: 91 93 st Z+, r25
944: 5f 01 movw r10, r30
946: 09 2e mov r0, r25
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:47
sum += value;
948: 00 0c add r0, r0
94a: aa 0b sbc r26, r26
94c: bb 0b sbc r27, r27
94e: c8 0e add r12, r24
950: d9 1e adc r13, r25
952: ea 1e adc r14, r26
954: fb 1e adc r15, r27
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:48
next += SAMPLE_PERIOD_US;
956: fd e7 ldi r31, 0x7D ; 125
958: 4f 0e add r4, r31
95a: 51 1c adc r5, r1
95c: 61 1c adc r6, r1
95e: 71 1c adc r7, r1
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:43
}
void captureSamples() {
uint32_t next = micros();
int32_t sum = 0;
for (uint16_t i = 0; i < SAMPLE_COUNT; ++i) {
960: 8a e0 ldi r24, 0x0A ; 10
962: a8 16 cp r10, r24
964: 8a e3 ldi r24, 0x3A ; 58
966: b8 06 cpc r11, r24
968: 81 f6 brne .-96 ; 0x90a <__DATA_REGION_LENGTH__+0x10a>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:51
samples[i] = value;
sum += value;
next += SAMPLE_PERIOD_US;
}
const int16_t mean = sum / SAMPLE_COUNT;
96a: c7 01 movw r24, r14
96c: b6 01 movw r22, r12
96e: 20 e0 ldi r18, 0x00 ; 0
970: 31 e0 ldi r19, 0x01 ; 1
972: 40 e0 ldi r20, 0x00 ; 0
974: 50 e0 ldi r21, 0x00 ; 0
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:52
for (uint16_t i = 0; i < SAMPLE_COUNT; ++i) samples[i] -= mean;
976: e8 d2 rcall .+1488 ; 0xf48 <__divmodsi4>
978: f8 01 movw r30, r16
97a: 81 91 ld r24, Z+
97c: 91 91 ld r25, Z+
97e: 8f 01 movw r16, r30
980: 32 97 sbiw r30, 0x02 ; 2
982: 82 1b sub r24, r18
984: 93 0b sbc r25, r19
986: 80 83 st Z, r24
988: 91 83 std Z+1, r25 ; 0x01
98a: fa e3 ldi r31, 0x3A ; 58
98c: 0a 30 cpi r16, 0x0A ; 10
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:56
}
float estimateFrequency() {
return tuner::estimate(samples) * SAMPLE_CLOCK_SCALE;
98e: 1f 07 cpc r17, r31
990: 99 f7 brne .-26 ; 0x978 <__DATA_REGION_LENGTH__+0x178>
estimateFrequency():
992: be db rcall .-2180 ; 0x110 <tuner::estimate(int const*) [clone .constprop.3]>
994: 4b 01 movw r8, r22
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:73
}
return best;
}
void showTuning(float frequency) {
allLedsOff();
996: 5c 01 movw r10, r24
showTuning():
998: c8 de rcall .-624 ; 0x72a <allLedsOff()>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:74
if (frequency <= 0.0f) return;
99a: 20 e0 ldi r18, 0x00 ; 0
99c: 30 e0 ldi r19, 0x00 ; 0
99e: a9 01 movw r20, r18
9a0: c5 01 movw r24, r10
9a2: b4 01 movw r22, r8
9a4: d4 d0 rcall .+424 ; 0xb4e <__cmpsf2>
9a6: 18 16 cp r1, r24
9a8: 0c f0 brlt .+2 ; 0x9ac <__DATA_REGION_LENGTH__+0x1ac>
9aa: 7b cf rjmp .-266 ; 0x8a2 <__DATA_REGION_LENGTH__+0xa2>
9ac: 8b e1 ldi r24, 0x1B ; 27
9ae: 90 e9 ldi r25, 0x90 ; 144
9b0: 8a 87 std Y+10, r24 ; 0x0a
9b2: 9b 87 std Y+11, r25 ; 0x0b
main():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:60
float estimateFrequency() {
return tuner::estimate(samples) * SAMPLE_CLOCK_SCALE;
}
uint8_t nearestString(float frequency) {
uint8_t best = 0;
9b4: 00 e0 ldi r16, 0x00 ; 0
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:61
float smallestError = 100000.0f;
9b6: 71 2c mov r7, r1
9b8: 90 e5 ldi r25, 0x50 ; 80
9ba: 69 2e mov r6, r25
9bc: 23 ec ldi r18, 0xC3 ; 195
9be: 52 2e mov r5, r18
9c0: 37 e4 ldi r19, 0x47 ; 71
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:62
for (uint8_t i = 0; i < 6; ++i) {
9c2: 43 2e mov r4, r19
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:63
const float cents = fabsf(1731.234049f * logf(frequency / STRING_HZ[i]));
9c4: 10 e0 ldi r17, 0x00 ; 0
nearestString():
9c6: ea 85 ldd r30, Y+10 ; 0x0a
9c8: fb 85 ldd r31, Y+11 ; 0x0b
9ca: 21 91 ld r18, Z+
9cc: 31 91 ld r19, Z+
9ce: 41 91 ld r20, Z+
9d0: 51 91 ld r21, Z+
9d2: ea 87 std Y+10, r30 ; 0x0a
9d4: fb 87 std Y+11, r31 ; 0x0b
9d6: c5 01 movw r24, r10
9d8: b4 01 movw r22, r8
9da: bd d0 rcall .+378 ; 0xb56 <__divsf3>
9dc: df d1 rcall .+958 ; 0xd9c <log>
9de: 2d e7 ldi r18, 0x7D ; 125
9e0: 37 e6 ldi r19, 0x67 ; 103
9e2: 48 ed ldi r20, 0xD8 ; 216
9e4: 54 e4 ldi r21, 0x44 ; 68
9e6: 1a d2 rcall .+1076 ; 0xe1c <__mulsf3>
9e8: 6b 01 movw r12, r22
9ea: 7c 01 movw r14, r24
9ec: e8 94 clt
9ee: f7 f8 bld r15, 7
9f0: a7 01 movw r20, r14
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:64
if (cents < smallestError) {
9f2: 96 01 movw r18, r12
9f4: 67 2d mov r22, r7
9f6: 76 2d mov r23, r6
9f8: 85 2d mov r24, r5
9fa: 94 2d mov r25, r4
9fc: c6 d1 rcall .+908 ; 0xd8a <__gesf2>
9fe: 18 16 cp r1, r24
a00: 2c f4 brge .+10 ; 0xa0c <__DATA_REGION_LENGTH__+0x20c>
main():
a02: 7c 2c mov r7, r12
a04: 6d 2c mov r6, r13
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:65
smallestError = cents;
a06: 5e 2c mov r5, r14
a08: 4f 2c mov r4, r15
nearestString():
a0a: 01 2f mov r16, r17
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:62
}
uint8_t nearestString(float frequency) {
uint8_t best = 0;
float smallestError = 100000.0f;
for (uint8_t i = 0; i < 6; ++i) {
a0c: 1f 5f subi r17, 0xFF ; 255
a0e: 16 30 cpi r17, 0x06 ; 6
a10: d1 f6 brne .-76 ; 0x9c6 <__DATA_REGION_LENGTH__+0x1c6>
showTuning():
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:77
void showTuning(float frequency) {
allLedsOff();
if (frequency <= 0.0f) return;
const uint8_t stringIndex = nearestString(frequency);
digitalWrite(NOTE_LEDS[stringIndex], HIGH);
a12: 10 e0 ldi r17, 0x00 ; 0
a14: f8 01 movw r30, r16
a16: ed 5c subi r30, 0xCD ; 205
a18: ff 46 sbci r31, 0x6F ; 111
a1a: 61 e0 ldi r22, 0x01 ; 1
a1c: 80 81 ld r24, Z
a1e: 03 de rcall .-1018 ; 0x626 <digitalWrite>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:78
const float cents = 1731.234049f * logf(frequency / STRING_HZ[stringIndex]);
a20: 00 0f add r16, r16
a22: 11 1f adc r17, r17
a24: 00 0f add r16, r16
a26: 11 1f adc r17, r17
a28: f8 01 movw r30, r16
a2a: e5 5e subi r30, 0xE5 ; 229
a2c: ff 46 sbci r31, 0x6F ; 111
a2e: 20 81 ld r18, Z
a30: 31 81 ldd r19, Z+1 ; 0x01
a32: 42 81 ldd r20, Z+2 ; 0x02
a34: 53 81 ldd r21, Z+3 ; 0x03
a36: c5 01 movw r24, r10
a38: b4 01 movw r22, r8
a3a: 8d d0 rcall .+282 ; 0xb56 <__divsf3>
a3c: af d1 rcall .+862 ; 0xd9c <log>
a3e: 2d e7 ldi r18, 0x7D ; 125
a40: 37 e6 ldi r19, 0x67 ; 103
a42: 48 ed ldi r20, 0xD8 ; 216
a44: 54 e4 ldi r21, 0x44 ; 68
a46: ea d1 rcall .+980 ; 0xe1c <__mulsf3>
a48: 6b 01 movw r12, r22
a4a: 7c 01 movw r14, r24
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:79
if (cents < -IN_TUNE_CENTS) digitalWrite(FLAT_LED, HIGH);
a4c: 20 e0 ldi r18, 0x00 ; 0
a4e: 30 e0 ldi r19, 0x00 ; 0
a50: 40 e8 ldi r20, 0x80 ; 128
a52: 50 ec ldi r21, 0xC0 ; 192
a54: 7c d0 rcall .+248 ; 0xb4e <__cmpsf2>
a56: 87 ff sbrs r24, 7
a58: 07 c0 rjmp .+14 ; 0xa68 <__DATA_REGION_LENGTH__+0x268>
a5a: 61 e0 ldi r22, 0x01 ; 1
a5c: 86 e0 ldi r24, 0x06 ; 6
a5e: e3 dd rcall .-1082 ; 0x626 <digitalWrite>
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:81
else if (cents > IN_TUNE_CENTS) digitalWrite(SHARP_LED, HIGH);
else digitalWrite(TUNE_LED, HIGH);
a60: 20 cf rjmp .-448 ; 0x8a2 <__DATA_REGION_LENGTH__+0xa2>
main():
a62: 89 ef ldi r24, 0xF9 ; 249
a64: 92 e8 ldi r25, 0x82 ; 130
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/.tscircuit/toolchain/data/packages/megaTinyCore/hardware/megaavr/2.6.11/cores/megatinycore/wiring_analog.c:716
// don't waste flash on smallest parts.
if ((pin & 0x7F) > 0x1F) { // highest valid mux value for any 0 or 1-series part.
return ADC_ERROR_BAD_PIN_OR_CHANNEL;
}
#endif
if (!ADC0.CTRLA & 0x01) return ADC_ERROR_DISABLED;
a66: 6b cf rjmp .-298 ; 0x93e <__DATA_REGION_LENGTH__+0x13e>
showTuning():
a68: 20 e0 ldi r18, 0x00 ; 0
a6a: 30 e0 ldi r19, 0x00 ; 0
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:80
const uint8_t stringIndex = nearestString(frequency);
digitalWrite(NOTE_LEDS[stringIndex], HIGH);
const float cents = 1731.234049f * logf(frequency / STRING_HZ[stringIndex]);
if (cents < -IN_TUNE_CENTS) digitalWrite(FLAT_LED, HIGH);
else if (cents > IN_TUNE_CENTS) digitalWrite(SHARP_LED, HIGH);
a6c: 40 e8 ldi r20, 0x80 ; 128
a6e: 50 e4 ldi r21, 0x40 ; 64
a70: c7 01 movw r24, r14
a72: b6 01 movw r22, r12
a74: 8a d1 rcall .+788 ; 0xd8a <__gesf2>
a76: 61 e0 ldi r22, 0x01 ; 1
a78: 18 16 cp r1, r24
a7a: 14 f4 brge .+4 ; 0xa80 <__DATA_REGION_LENGTH__+0x280>
a7c: 87 e0 ldi r24, 0x07 ; 7
a7e: ef cf rjmp .-34 ; 0xa5e <__DATA_REGION_LENGTH__+0x25e>
a80: 88 e0 ldi r24, 0x08 ; 8
a82: ed cf rjmp .-38 ; 0xa5e <__DATA_REGION_LENGTH__+0x25e>
00000a84 <__subsf3>:
__subsf3():
a84: 50 58 subi r21, 0x80 ; 128
00000a86 <__addsf3>:
/Users/gokul/Documents/Codex/2026-09-09/is-t/outputs/acoustic-guitar-tuner/firmware/acoustic_tuner_attiny1616/acoustic_tuner_attiny1616.ino:81
else digitalWrite(TUNE_LED, HIGH);
a86: bb 27 eor r27, r27
a88: aa 27 eor r26, r26
a8a: 0e d0 rcall .+28 ; 0xaa8 <__addsf3x>
a8c: 44 c1 rjmp .+648 ; 0xd16 <__fp_round>
__addsf3():
a8e: 35 d1 rcall .+618 ; 0xcfa <__fp_pscA>
a90: 30 f0 brcs .+12 ; 0xa9e <__addsf3+0x18>
a92: 3a d1 rcall .+628 ; 0xd08 <__fp_pscB>
a94: 20 f0 brcs .+8 ; 0xa9e <__addsf3+0x18>
a96: 31 f4 brne .+12 ; 0xaa4 <__addsf3+0x1e>
a98: 9f 3f cpi r25, 0xFF ; 255
a9a: 11 f4 brne .+4 ; 0xaa0 <__addsf3+0x1a>
a9c: 1e f4 brtc .+6 ; 0xaa4 <__addsf3+0x1e>
a9e: 2a c1 rjmp .+596 ; 0xcf4 <__fp_nan>
aa0: 0e f4 brtc .+2 ; 0xaa4 <__addsf3+0x1e>
aa2: e0 95 com r30
aa4: e7 fb bst r30, 7
aa6: 20 c1 rjmp .+576 ; 0xce8 <__fp_inf>
00000aa8 <__addsf3x>:
__addsf3x():
aa8: e9 2f mov r30, r25
aaa: 46 d1 rcall .+652 ; 0xd38 <__fp_split3>
aac: 80 f3 brcs .-32 ; 0xa8e <__addsf3+0x8>
aae: ba 17 cp r27, r26
ab0: 62 07 cpc r22, r18
ab2: 73 07 cpc r23, r19
ab4: 84 07 cpc r24, r20
ab6: 95 07 cpc r25, r21
ab8: 18 f0 brcs .+6 ; 0xac0 <__addsf3x+0x18>
aba: 71 f4 brne .+28 ; 0xad8 <__addsf3x+0x30>
abc: 9e f5 brtc .+102 ; 0xb24 <__addsf3x+0x7c>
abe: 5e c1 rjmp .+700 ; 0xd7c <__fp_zero>
ac0: 0e f4 brtc .+2 ; 0xac4 <__addsf3x+0x1c>
ac2: e0 95 com r30
ac4: 0b 2e mov r0, r27
ac6: ba 2f mov r27, r26
ac8: a0 2d mov r26, r0
aca: 0b 01 movw r0, r22
acc: b9 01 movw r22, r18
ace: 90 01 movw r18, r0
ad0: 0c 01 movw r0, r24
ad2: ca 01 movw r24, r20
ad4: a0 01 movw r20, r0
ad6: 11 24 eor r1, r1
ad8: ff 27 eor r31, r31
ada: 59 1b sub r21, r25
adc: 99 f0 breq .+38 ; 0xb04 <__addsf3x+0x5c>
ade: 59 3f cpi r21, 0xF9 ; 249
ae0: 50 f4 brcc .+20 ; 0xaf6 <__addsf3x+0x4e>
ae2: 50 3e cpi r21, 0xE0 ; 224
ae4: 68 f1 brcs .+90 ; 0xb40 <__addsf3x+0x98>
ae6: 1a 16 cp r1, r26
ae8: f0 40 sbci r31, 0x00 ; 0
aea: a2 2f mov r26, r18
aec: 23 2f mov r18, r19
aee: 34 2f mov r19, r20
af0: 44 27 eor r20, r20
af2: 58 5f subi r21, 0xF8 ; 248
af4: f3 cf rjmp .-26 ; 0xadc <__addsf3x+0x34>
af6: 46 95 lsr r20
af8: 37 95 ror r19
afa: 27 95 ror r18
afc: a7 95 ror r26
afe: f0 40 sbci r31, 0x00 ; 0
b00: 53 95 inc r21
b02: c9 f7 brne .-14 ; 0xaf6 <__addsf3x+0x4e>
b04: 7e f4 brtc .+30 ; 0xb24 <__addsf3x+0x7c>
b06: 1f 16 cp r1, r31
b08: ba 0b sbc r27, r26
b0a: 62 0b sbc r22, r18
b0c: 73 0b sbc r23, r19
b0e: 84 0b sbc r24, r20
b10: ba f0 brmi .+46 ; 0xb40 <__addsf3x+0x98>
b12: 91 50 subi r25, 0x01 ; 1
b14: a1 f0 breq .+40 ; 0xb3e <__addsf3x+0x96>
b16: ff 0f add r31, r31
b18: bb 1f adc r27, r27
b1a: 66 1f adc r22, r22
b1c: 77 1f adc r23, r23
b1e: 88 1f adc r24, r24
b20: c2 f7 brpl .-16 ; 0xb12 <__addsf3x+0x6a>
b22: 0e c0 rjmp .+28 ; 0xb40 <__addsf3x+0x98>
b24: ba 0f add r27, r26
b26: 62 1f adc r22, r18
b28: 73 1f adc r23, r19
b2a: 84 1f adc r24, r20
b2c: 48 f4 brcc .+18 ; 0xb40 <__addsf3x+0x98>
b2e: 87 95 ror r24
b30: 77 95 ror r23
b32: 67 95 ror r22
b34: b7 95 ror r27
b36: f7 95 ror r31
b38: 9e 3f cpi r25, 0xFE ; 254
b3a: 08 f0 brcs .+2 ; 0xb3e <__addsf3x+0x96>
b3c: b3 cf rjmp .-154 ; 0xaa4 <__addsf3+0x1e>
b3e: 93 95 inc r25
b40: 88 0f add r24, r24
b42: 08 f0 brcs .+2 ; 0xb46 <__addsf3x+0x9e>
b44: 99 27 eor r25, r25
b46: ee 0f add r30, r30
b48: 97 95 ror r25
b4a: 87 95 ror r24
b4c: 08 95 ret
00000b4e <__cmpsf2>:
b4e: a8 d0 rcall .+336 ; 0xca0 <__fp_cmp>
b50: 08 f4 brcc .+2 ; 0xb54 <__cmpsf2+0x6>
b52: 81 e0 ldi r24, 0x01 ; 1
b54: 08 95 ret
00000b56 <__divsf3>:
b56: 0c d0 rcall .+24 ; 0xb70 <__divsf3x>
b58: de c0 rjmp .+444 ; 0xd16 <__fp_round>
b5a: d6 d0 rcall .+428 ; 0xd08 <__fp_pscB>
b5c: 40 f0 brcs .+16 ; 0xb6e <__divsf3+0x18>
b5e: cd d0 rcall .+410 ; 0xcfa <__fp_pscA>
b60: 30 f0 brcs .+12 ; 0xb6e <__divsf3+0x18>
b62: 21 f4 brne .+8 ; 0xb6c <__divsf3+0x16>
b64: 5f 3f cpi r21, 0xFF ; 255
b66: 19 f0 breq .+6 ; 0xb6e <__divsf3+0x18>
b68: bf c0 rjmp .+382 ; 0xce8 <__fp_inf>
b6a: 51 11 cpse r21, r1
b6c: 08 c1 rjmp .+528 ; 0xd7e <__fp_szero>
b6e: c2 c0 rjmp .+388 ; 0xcf4 <__fp_nan>
00000b70 <__divsf3x>:
b70: e3 d0 rcall .+454 ; 0xd38 <__fp_split3>
b72: 98 f3 brcs .-26 ; 0xb5a <__divsf3+0x4>
00000b74 <__divsf3_pse>:
__divsf3_pse():
b74: 99 23 and r25, r25
b76: c9 f3 breq .-14 ; 0xb6a <__divsf3+0x14>
b78: 55 23 and r21, r21
b7a: b1 f3 breq .-20 ; 0xb68 <__divsf3+0x12>
b7c: 95 1b sub r25, r21
b7e: 55 0b sbc r21, r21
b80: bb 27 eor r27, r27
b82: aa 27 eor r26, r26
b84: 62 17 cp r22, r18
b86: 73 07 cpc r23, r19
b88: 84 07 cpc r24, r20
b8a: 38 f0 brcs .+14 ; 0xb9a <__divsf3_pse+0x26>
b8c: 9f 5f subi r25, 0xFF ; 255
b8e: 5f 4f sbci r21, 0xFF ; 255
b90: 22 0f add r18, r18
b92: 33 1f adc r19, r19
b94: 44 1f adc r20, r20
b96: aa 1f adc r26, r26
b98: a9 f3 breq .-22 ; 0xb84 <__divsf3_pse+0x10>
b9a: 33 d0 rcall .+102 ; 0xc02 <__divsf3_pse+0x8e>
b9c: 0e 2e mov r0, r30
b9e: 3a f0 brmi .+14 ; 0xbae <__divsf3_pse+0x3a>
ba0: e0 e8 ldi r30, 0x80 ; 128
ba2: 30 d0 rcall .+96 ; 0xc04 <__divsf3_pse+0x90>
ba4: 91 50 subi r25, 0x01 ; 1
ba6: 50 40 sbci r21, 0x00 ; 0
ba8: e6 95 lsr r30
baa: 00 1c adc r0, r0
bac: ca f7 brpl .-14 ; 0xba0 <__divsf3_pse+0x2c>
bae: 29 d0 rcall .+82 ; 0xc02 <__divsf3_pse+0x8e>
bb0: fe 2f mov r31, r30
bb2: 27 d0 rcall .+78 ; 0xc02 <__divsf3_pse+0x8e>
bb4: 66 0f add r22, r22
bb6: 77 1f adc r23, r23
bb8: 88 1f adc r24, r24
bba: bb 1f adc r27, r27
bbc: 26 17 cp r18, r22
bbe: 37 07 cpc r19, r23
bc0: 48 07 cpc r20, r24
bc2: ab 07 cpc r26, r27
bc4: b0 e8 ldi r27, 0x80 ; 128
bc6: 09 f0 breq .+2 ; 0xbca <__divsf3_pse+0x56>
bc8: bb 0b sbc r27, r27
bca: 80 2d mov r24, r0
bcc: bf 01 movw r22, r30
bce: ff 27 eor r31, r31
bd0: 93 58 subi r25, 0x83 ; 131
bd2: 5f 4f sbci r21, 0xFF ; 255
bd4: 2a f0 brmi .+10 ; 0xbe0 <__divsf3_pse+0x6c>
bd6: 9e 3f cpi r25, 0xFE ; 254
bd8: 51 05 cpc r21, r1
bda: 68 f0 brcs .+26 ; 0xbf6 <__divsf3_pse+0x82>
bdc: 85 c0 rjmp .+266 ; 0xce8 <__fp_inf>
bde: cf c0 rjmp .+414 ; 0xd7e <__fp_szero>
be0: 5f 3f cpi r21, 0xFF ; 255
be2: ec f3 brlt .-6 ; 0xbde <__divsf3_pse+0x6a>
be4: 98 3e cpi r25, 0xE8 ; 232
be6: dc f3 brlt .-10 ; 0xbde <__divsf3_pse+0x6a>
be8: 86 95 lsr r24
bea: 77 95 ror r23
bec: 67 95 ror r22
bee: b7 95 ror r27
bf0: f7 95 ror r31
bf2: 9f 5f subi r25, 0xFF ; 255
bf4: c9 f7 brne .-14 ; 0xbe8 <__divsf3_pse+0x74>
bf6: 88 0f add r24, r24
bf8: 91 1d adc r25, r1
bfa: 96 95 lsr r25
bfc: 87 95 ror r24
bfe: 97 f9 bld r25, 7
c00: 08 95 ret
c02: e1 e0 ldi r30, 0x01 ; 1
c04: 66 0f add r22, r22
c06: 77 1f adc r23, r23
c08: 88 1f adc r24, r24
c0a: bb 1f adc r27, r27
c0c: 62 17 cp r22, r18
c0e: 73 07 cpc r23, r19
c10: 84 07 cpc r24, r20
c12: ba 07 cpc r27, r26
c14: 20 f0 brcs .+8 ; 0xc1e <__divsf3_pse+0xaa>
c16: 62 1b sub r22, r18
c18: 73 0b sbc r23, r19
c1a: 84 0b sbc r24, r20
c1c: ba 0b sbc r27, r26
c1e: ee 1f adc r30, r30
c20: 88 f7 brcc .-30 ; 0xc04 <__divsf3_pse+0x90>
c22: e0 95 com r30
c24: 08 95 ret
00000c26 <__floatunsisf>:
__floatunsisf():
c26: e8 94 clt
c28: 09 c0 rjmp .+18 ; 0xc3c <__floatsisf+0x12>
00000c2a <__floatsisf>:
c2a: 97 fb bst r25, 7
c2c: 3e f4 brtc .+14 ; 0xc3c <__floatsisf+0x12>
c2e: 90 95 com r25
c30: 80 95 com r24
c32: 70 95 com r23
c34: 61 95 neg r22
c36: 7f 4f sbci r23, 0xFF ; 255
c38: 8f 4f sbci r24, 0xFF ; 255
c3a: 9f 4f sbci r25, 0xFF ; 255
c3c: 99 23 and r25, r25
c3e: a9 f0 breq .+42 ; 0xc6a <__floatsisf+0x40>
c40: f9 2f mov r31, r25
c42: 96 e9 ldi r25, 0x96 ; 150
c44: bb 27 eor r27, r27
c46: 93 95 inc r25
c48: f6 95 lsr r31
c4a: 87 95 ror r24
c4c: 77 95 ror r23
c4e: 67 95 ror r22
c50: b7 95 ror r27
c52: f1 11 cpse r31, r1
c54: f8 cf rjmp .-16 ; 0xc46 <__floatsisf+0x1c>
c56: fa f4 brpl .+62 ; 0xc96 <__floatsisf+0x6c>
c58: bb 0f add r27, r27
c5a: 11 f4 brne .+4 ; 0xc60 <__floatsisf+0x36>
c5c: 60 ff sbrs r22, 0
c5e: 1b c0 rjmp .+54 ; 0xc96 <__floatsisf+0x6c>
c60: 6f 5f subi r22, 0xFF ; 255
c62: 7f 4f sbci r23, 0xFF ; 255
c64: 8f 4f sbci r24, 0xFF ; 255
c66: 9f 4f sbci r25, 0xFF ; 255
c68: 16 c0 rjmp .+44 ; 0xc96 <__floatsisf+0x6c>
c6a: 88 23 and r24, r24
c6c: 11 f0 breq .+4 ; 0xc72 <__floatsisf+0x48>
c6e: 96 e9 ldi r25, 0x96 ; 150
c70: 11 c0 rjmp .+34 ; 0xc94 <__floatsisf+0x6a>
c72: 77 23 and r23, r23
c74: 21 f0 breq .+8 ; 0xc7e <__floatsisf+0x54>
c76: 9e e8 ldi r25, 0x8E ; 142
c78: 87 2f mov r24, r23
c7a: 76 2f mov r23, r22
c7c: 05 c0 rjmp .+10 ; 0xc88 <__floatsisf+0x5e>
c7e: 66 23 and r22, r22
c80: 71 f0 breq .+28 ; 0xc9e <__floatsisf+0x74>
c82: 96 e8 ldi r25, 0x86 ; 134
c84: 86 2f mov r24, r22
c86: 70 e0 ldi r23, 0x00 ; 0
c88: 60 e0 ldi r22, 0x00 ; 0
c8a: 2a f0 brmi .+10 ; 0xc96 <__floatsisf+0x6c>
c8c: 9a 95 dec r25
c8e: 66 0f add r22, r22
c90: 77 1f adc r23, r23
c92: 88 1f adc r24, r24
c94: da f7 brpl .-10 ; 0xc8c <__floatsisf+0x62>
c96: 88 0f add r24, r24
c98: 96 95 lsr r25
c9a: 87 95 ror r24
c9c: 97 f9 bld r25, 7
c9e: 08 95 ret
00000ca0 <__fp_cmp>:
__fp_cmp():
ca0: 99 0f add r25, r25
ca2: 00 08 sbc r0, r0
ca4: 55 0f add r21, r21
ca6: aa 0b sbc r26, r26
ca8: e0 e8 ldi r30, 0x80 ; 128
caa: fe ef ldi r31, 0xFE ; 254
cac: 16 16 cp r1, r22
cae: 17 06 cpc r1, r23
cb0: e8 07 cpc r30, r24
cb2: f9 07 cpc r31, r25
cb4: c0 f0 brcs .+48 ; 0xce6 <__fp_cmp+0x46>
cb6: 12 16 cp r1, r18
cb8: 13 06 cpc r1, r19
cba: e4 07 cpc r30, r20
cbc: f5 07 cpc r31, r21
cbe: 98 f0 brcs .+38 ; 0xce6 <__fp_cmp+0x46>
cc0: 62 1b sub r22, r18
cc2: 73 0b sbc r23, r19
cc4: 84 0b sbc r24, r20
cc6: 95 0b sbc r25, r21
cc8: 39 f4 brne .+14 ; 0xcd8 <__fp_cmp+0x38>
cca: 0a 26 eor r0, r26
ccc: 61 f0 breq .+24 ; 0xce6 <__fp_cmp+0x46>
cce: 23 2b or r18, r19
cd0: 24 2b or r18, r20
cd2: 25 2b or r18, r21
cd4: 21 f4 brne .+8 ; 0xcde <__fp_cmp+0x3e>
cd6: 08 95 ret
cd8: 0a 26 eor r0, r26
cda: 09 f4 brne .+2 ; 0xcde <__fp_cmp+0x3e>
cdc: a1 40 sbci r26, 0x01 ; 1
cde: a6 95 lsr r26
ce0: 8f ef ldi r24, 0xFF ; 255
ce2: 81 1d adc r24, r1
ce4: 81 1d adc r24, r1
ce6: 08 95 ret
00000ce8 <__fp_inf>:
__fp_inf():
ce8: 97 f9 bld r25, 7
cea: 9f 67 ori r25, 0x7F ; 127
cec: 80 e8 ldi r24, 0x80 ; 128
cee: 70 e0 ldi r23, 0x00 ; 0
cf0: 60 e0 ldi r22, 0x00 ; 0
cf2: 08 95 ret
00000cf4 <__fp_nan>:
__fp_nan():
cf4: 9f ef ldi r25, 0xFF ; 255
cf6: 80 ec ldi r24, 0xC0 ; 192
cf8: 08 95 ret
00000cfa <__fp_pscA>:
__fp_pscA():
cfa: 00 24 eor r0, r0
cfc: 0a 94 dec r0
cfe: 16 16 cp r1, r22
d00: 17 06 cpc r1, r23
d02: 18 06 cpc r1, r24
d04: 09 06 cpc r0, r25
d06: 08 95 ret
00000d08 <__fp_pscB>:
__fp_pscB():
d08: 00 24 eor r0, r0
d0a: 0a 94 dec r0
d0c: 12 16 cp r1, r18
d0e: 13 06 cpc r1, r19
d10: 14 06 cpc r1, r20
d12: 05 06 cpc r0, r21
d14: 08 95 ret
00000d16 <__fp_round>:
__fp_round():
d16: 09 2e mov r0, r25
d18: 03 94 inc r0
d1a: 00 0c add r0, r0
d1c: 11 f4 brne .+4 ; 0xd22 <__fp_round+0xc>
d1e: 88 23 and r24, r24
d20: 52 f0 brmi .+20 ; 0xd36 <__fp_round+0x20>
d22: bb 0f add r27, r27
d24: 40 f4 brcc .+16 ; 0xd36 <__fp_round+0x20>
d26: bf 2b or r27, r31
d28: 11 f4 brne .+4 ; 0xd2e <__fp_round+0x18>
d2a: 60 ff sbrs r22, 0
d2c: 04 c0 rjmp .+8 ; 0xd36 <__fp_round+0x20>
d2e: 6f 5f subi r22, 0xFF ; 255
d30: 7f 4f sbci r23, 0xFF ; 255
d32: 8f 4f sbci r24, 0xFF ; 255
d34: 9f 4f sbci r25, 0xFF ; 255
d36: 08 95 ret
00000d38 <__fp_split3>:
__fp_split3():
d38: 57 fd sbrc r21, 7
d3a: 90 58 subi r25, 0x80 ; 128
d3c: 44 0f add r20, r20
d3e: 55 1f adc r21, r21
d40: 59 f0 breq .+22 ; 0xd58 <__fp_splitA+0x10>
d42: 5f 3f cpi r21, 0xFF ; 255
d44: 71 f0 breq .+28 ; 0xd62 <__fp_splitA+0x1a>
d46: 47 95 ror r20
00000d48 <__fp_splitA>:
d48: 88 0f add r24, r24
d4a: 97 fb bst r25, 7
d4c: 99 1f adc r25, r25
d4e: 61 f0 breq .+24 ; 0xd68 <__fp_splitA+0x20>
d50: 9f 3f cpi r25, 0xFF ; 255
d52: 79 f0 breq .+30 ; 0xd72 <__fp_splitA+0x2a>
d54: 87 95 ror r24
d56: 08 95 ret
d58: 12 16 cp r1, r18
d5a: 13 06 cpc r1, r19
d5c: 14 06 cpc r1, r20
d5e: 55 1f adc r21, r21
d60: f2 cf rjmp .-28 ; 0xd46 <__fp_split3+0xe>
d62: 46 95 lsr r20
d64: f1 df rcall .-30 ; 0xd48 <__fp_splitA>
d66: 08 c0 rjmp .+16 ; 0xd78 <__fp_splitA+0x30>
d68: 16 16 cp r1, r22
d6a: 17 06 cpc r1, r23
d6c: 18 06 cpc r1, r24
d6e: 99 1f adc r25, r25
d70: f1 cf rjmp .-30 ; 0xd54 <__fp_splitA+0xc>
d72: 86 95 lsr r24
d74: 71 05 cpc r23, r1
d76: 61 05 cpc r22, r1
d78: 08 94 sec
d7a: 08 95 ret
00000d7c <__fp_zero>:
__fp_zero():
d7c: e8 94 clt
00000d7e <__fp_szero>:
d7e: bb 27 eor r27, r27
d80: 66 27 eor r22, r22
d82: 77 27 eor r23, r23
d84: cb 01 movw r24, r22
d86: 97 f9 bld r25, 7
d88: 08 95 ret
00000d8a <__gesf2>:
__gesf2():
d8a: 8a df rcall .-236 ; 0xca0 <__fp_cmp>
d8c: 08 f4 brcc .+2 ; 0xd90 <__gesf2+0x6>
d8e: 8f ef ldi r24, 0xFF ; 255
d90: 08 95 ret
d92: 0e f0 brts .+2 ; 0xd96 <__gesf2+0xc>
d94: a6 c0 rjmp .+332 ; 0xee2 <__fp_mpack>
d96: ae cf rjmp .-164 ; 0xcf4 <__fp_nan>
d98: 68 94 set
d9a: a6 cf rjmp .-180 ; 0xce8 <__fp_inf>
00000d9c <log>:
log():
d9c: d5 df rcall .-86 ; 0xd48 <__fp_splitA>
d9e: c8 f3 brcs .-14 ; 0xd92 <__gesf2+0x8>
da0: 99 23 and r25, r25
da2: d1 f3 breq .-12 ; 0xd98 <__gesf2+0xe>
da4: c6 f3 brts .-16 ; 0xd96 <__gesf2+0xc>
da6: df 93 push r29
da8: cf 93 push r28
daa: 1f 93 push r17
dac: 0f 93 push r16
dae: ff 92 push r15
db0: c9 2f mov r28, r25
db2: dd 27 eor r29, r29
db4: 88 23 and r24, r24
db6: 2a f0 brmi .+10 ; 0xdc2 <log+0x26>
db8: 21 97 sbiw r28, 0x01 ; 1
dba: 66 0f add r22, r22
dbc: 77 1f adc r23, r23
dbe: 88 1f adc r24, r24
dc0: da f7 brpl .-10 ; 0xdb8 <log+0x1c>
dc2: 20 e0 ldi r18, 0x00 ; 0
dc4: 30 e0 ldi r19, 0x00 ; 0
dc6: 40 e8 ldi r20, 0x80 ; 128
dc8: 5f eb ldi r21, 0xBF ; 191
dca: 9f e3 ldi r25, 0x3F ; 63
dcc: 88 39 cpi r24, 0x98 ; 152
dce: 20 f0 brcs .+8 ; 0xdd8 <log+0x3c>
dd0: 80 3e cpi r24, 0xE0 ; 224
dd2: 30 f0 brcs .+12 ; 0xde0 <log+0x44>
dd4: 21 96 adiw r28, 0x01 ; 1
dd6: 8f 77 andi r24, 0x7F ; 127
dd8: 56 de rcall .-852 ; 0xa86 <__addsf3>
dda: ec e7 ldi r30, 0x7C ; 124
ddc: f0 e0 ldi r31, 0x00 ; 0
dde: 03 c0 rjmp .+6 ; 0xde6 <log+0x4a>
de0: 52 de rcall .-860 ; 0xa86 <__addsf3>
de2: e9 ea ldi r30, 0xA9 ; 169
de4: f0 e0 ldi r31, 0x00 ; 0
de6: 8b d0 rcall .+278 ; 0xefe <__fp_powser>
de8: 8b 01 movw r16, r22
dea: be 01 movw r22, r28
dec: ec 01 movw r28, r24
dee: fb 2e mov r15, r27
df0: 6f 57 subi r22, 0x7F ; 127
df2: 71 09 sbc r23, r1
df4: 75 95 asr r23
df6: 77 1f adc r23, r23
df8: 88 0b sbc r24, r24
dfa: 99 0b sbc r25, r25
dfc: 16 df rcall .-468 ; 0xc2a <__floatsisf>
dfe: 28 e1 ldi r18, 0x18 ; 24
e00: 32 e7 ldi r19, 0x72 ; 114
e02: 41 e3 ldi r20, 0x31 ; 49
e04: 5f e3 ldi r21, 0x3F ; 63
e06: 16 d0 rcall .+44 ; 0xe34 <__mulsf3x>
e08: af 2d mov r26, r15
e0a: 98 01 movw r18, r16
e0c: ae 01 movw r20, r28
e0e: ff 90 pop r15
e10: 0f 91 pop r16
e12: 1f 91 pop r17
e14: cf 91 pop r28
e16: df 91 pop r29
e18: 47 de rcall .-882 ; 0xaa8 <__addsf3x>
e1a: 7d cf rjmp .-262 ; 0xd16 <__fp_round>
00000e1c <__mulsf3>:
e1c: 0b d0 rcall .+22 ; 0xe34 <__mulsf3x>
e1e: 7b cf rjmp .-266 ; 0xd16 <__fp_round>
e20: 6c df rcall .-296 ; 0xcfa <__fp_pscA>
e22: 28 f0 brcs .+10 ; 0xe2e <__mulsf3+0x12>
e24: 71 df rcall .-286 ; 0xd08 <__fp_pscB>
e26: 18 f0 brcs .+6 ; 0xe2e <__mulsf3+0x12>
e28: 95 23 and r25, r21
e2a: 09 f0 breq .+2 ; 0xe2e <__mulsf3+0x12>
e2c: 5d cf rjmp .-326 ; 0xce8 <__fp_inf>
e2e: 62 cf rjmp .-316 ; 0xcf4 <__fp_nan>
e30: 11 24 eor r1, r1
e32: a5 cf rjmp .-182 ; 0xd7e <__fp_szero>
00000e34 <__mulsf3x>:
e34: 81 df rcall .-254 ; 0xd38 <__fp_split3>
e36: a0 f3 brcs .-24 ; 0xe20 <__mulsf3+0x4>
00000e38 <__mulsf3_pse>:
e38: 95 9f mul r25, r21
e3a: d1 f3 breq .-12 ; 0xe30 <__mulsf3+0x14>
__mulsf3_pse():
e3c: 95 0f add r25, r21
e3e: 50 e0 ldi r21, 0x00 ; 0
e40: 55 1f adc r21, r21
e42: 62 9f mul r22, r18
e44: f0 01 movw r30, r0
e46: 72 9f mul r23, r18
e48: bb 27 eor r27, r27
e4a: f0 0d add r31, r0
e4c: b1 1d adc r27, r1
e4e: 63 9f mul r22, r19
e50: aa 27 eor r26, r26
e52: f0 0d add r31, r0
e54: b1 1d adc r27, r1
e56: aa 1f adc r26, r26
e58: 64 9f mul r22, r20
e5a: 66 27 eor r22, r22
e5c: b0 0d add r27, r0
e5e: a1 1d adc r26, r1
e60: 66 1f adc r22, r22
e62: 82 9f mul r24, r18
e64: 22 27 eor r18, r18
e66: b0 0d add r27, r0
e68: a1 1d adc r26, r1
e6a: 62 1f adc r22, r18
e6c: 73 9f mul r23, r19
e6e: b0 0d add r27, r0
e70: a1 1d adc r26, r1
e72: 62 1f adc r22, r18
e74: 83 9f mul r24, r19
e76: a0 0d add r26, r0
e78: 61 1d adc r22, r1
e7a: 22 1f adc r18, r18
e7c: 74 9f mul r23, r20
e7e: 33 27 eor r19, r19
e80: a0 0d add r26, r0
e82: 61 1d adc r22, r1
e84: 23 1f adc r18, r19
e86: 84 9f mul r24, r20
e88: 60 0d add r22, r0
e8a: 21 1d adc r18, r1
e8c: 82 2f mov r24, r18
e8e: 76 2f mov r23, r22
e90: 6a 2f mov r22, r26
e92: 11 24 eor r1, r1
e94: 9f 57 subi r25, 0x7F ; 127
e96: 50 40 sbci r21, 0x00 ; 0
e98: 8a f0 brmi .+34 ; 0xebc <__mulsf3_pse+0x84>
e9a: e1 f0 breq .+56 ; 0xed4 <__mulsf3_pse+0x9c>
e9c: 88 23 and r24, r24
e9e: 4a f0 brmi .+18 ; 0xeb2 <__mulsf3_pse+0x7a>
ea0: ee 0f add r30, r30
ea2: ff 1f adc r31, r31
ea4: bb 1f adc r27, r27
ea6: 66 1f adc r22, r22
ea8: 77 1f adc r23, r23
eaa: 88 1f adc r24, r24
eac: 91 50 subi r25, 0x01 ; 1
eae: 50 40 sbci r21, 0x00 ; 0
eb0: a9 f7 brne .-22 ; 0xe9c <__mulsf3_pse+0x64>
eb2: 9e 3f cpi r25, 0xFE ; 254
eb4: 51 05 cpc r21, r1
eb6: 70 f0 brcs .+28 ; 0xed4 <__mulsf3_pse+0x9c>
eb8: 17 cf rjmp .-466 ; 0xce8 <__fp_inf>
eba: 61 cf rjmp .-318 ; 0xd7e <__fp_szero>
ebc: 5f 3f cpi r21, 0xFF ; 255
ebe: ec f3 brlt .-6 ; 0xeba <__mulsf3_pse+0x82>
ec0: 98 3e cpi r25, 0xE8 ; 232
ec2: dc f3 brlt .-10 ; 0xeba <__mulsf3_pse+0x82>
ec4: 86 95 lsr r24
ec6: 77 95 ror r23
ec8: 67 95 ror r22
eca: b7 95 ror r27
ecc: f7 95 ror r31
ece: e7 95 ror r30
ed0: 9f 5f subi r25, 0xFF ; 255
ed2: c1 f7 brne .-16 ; 0xec4 <__mulsf3_pse+0x8c>
ed4: fe 2b or r31, r30
ed6: 88 0f add r24, r24
ed8: 91 1d adc r25, r1
eda: 96 95 lsr r25
edc: 87 95 ror r24
ede: 97 f9 bld r25, 7
ee0: 08 95 ret
00000ee2 <__fp_mpack>:
__fp_mpack():
ee2: 9f 3f cpi r25, 0xFF ; 255
ee4: 31 f0 breq .+12 ; 0xef2 <__fp_mpack_finite+0xc>
00000ee6 <__fp_mpack_finite>:
ee6: 91 50 subi r25, 0x01 ; 1
ee8: 20 f4 brcc .+8 ; 0xef2 <__fp_mpack_finite+0xc>
eea: 87 95 ror r24
eec: 77 95 ror r23
eee: 67 95 ror r22
ef0: b7 95 ror r27
ef2: 88 0f add r24, r24
ef4: 91 1d adc r25, r1
ef6: 96 95 lsr r25
ef8: 87 95 ror r24
efa: 97 f9 bld r25, 7
efc: 08 95 ret
00000efe <__fp_powser>:
__fp_powser():
efe: df 93 push r29
f00: cf 93 push r28
f02: 1f 93 push r17
f04: 0f 93 push r16
f06: ff 92 push r15
f08: ef 92 push r14
f0a: df 92 push r13
f0c: 7b 01 movw r14, r22
f0e: 8c 01 movw r16, r24
f10: 68 94 set
f12: 05 c0 rjmp .+10 ; 0xf1e <__fp_powser+0x20>
f14: da 2e mov r13, r26
f16: ef 01 movw r28, r30
f18: 8d df rcall .-230 ; 0xe34 <__mulsf3x>
f1a: fe 01 movw r30, r28
f1c: e8 94 clt
f1e: a5 91 lpm r26, Z+
f20: 25 91 lpm r18, Z+
f22: 35 91 lpm r19, Z+
f24: 45 91 lpm r20, Z+
f26: 55 91 lpm r21, Z+
f28: ae f3 brts .-22 ; 0xf14 <__fp_powser+0x16>
f2a: ef 01 movw r28, r30
f2c: bd dd rcall .-1158 ; 0xaa8 <__addsf3x>
f2e: fe 01 movw r30, r28
f30: 97 01 movw r18, r14
f32: a8 01 movw r20, r16
f34: da 94 dec r13
f36: 79 f7 brne .-34 ; 0xf16 <__fp_powser+0x18>
f38: df 90 pop r13
f3a: ef 90 pop r14
f3c: ff 90 pop r15
f3e: 0f 91 pop r16
f40: 1f 91 pop r17
f42: cf 91 pop r28
f44: df 91 pop r29
f46: 08 95 ret
00000f48 <__divmodsi4>:
__divmodsi4():
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1686
f48: 05 2e mov r0, r21
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1687
f4a: 97 fb bst r25, 7
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1688
f4c: 16 f4 brtc .+4 ; 0xf52 <__divmodsi4+0xa>
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1689
f4e: 00 94 com r0
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1690
f50: 0f d0 rcall .+30 ; 0xf70 <__negsi2>
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1692
f52: 57 fd sbrc r21, 7
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1694
f54: 05 d0 rcall .+10 ; 0xf60 <__divmodsi4_neg2>
f56: 39 d0 rcall .+114 ; 0xfca <__udivmodsi4>
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1695
f58: 07 fc sbrc r0, 7
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1697
f5a: 02 d0 rcall .+4 ; 0xf60 <__divmodsi4_neg2>
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1698
f5c: 46 f4 brtc .+16 ; 0xf6e <__divmodsi4_exit>
f5e: 08 c0 rjmp .+16 ; 0xf70 <__negsi2>
00000f60 <__divmodsi4_neg2>:
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1701
f60: 50 95 com r21
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1702
f62: 40 95 com r20
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1703
f64: 30 95 com r19
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1704
f66: 21 95 neg r18
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1705
f68: 3f 4f sbci r19, 0xFF ; 255
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1706
f6a: 4f 4f sbci r20, 0xFF ; 255
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1707
f6c: 5f 4f sbci r21, 0xFF ; 255
00000f6e <__divmodsi4_exit>:
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1709
f6e: 08 95 ret
00000f70 <__negsi2>:
__negsi2():
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1718
f70: 90 95 com r25
f72: 80 95 com r24
f74: 70 95 com r23
f76: 61 95 neg r22
f78: 7f 4f sbci r23, 0xFF ; 255
f7a: 8f 4f sbci r24, 0xFF ; 255
f7c: 9f 4f sbci r25, 0xFF ; 255
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1719
f7e: 08 95 ret
00000f80 <__mulhisi3>:
__mulhisi3():
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:529
f80: 05 d0 rcall .+10 ; 0xf8c <__umulhisi3>
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:531
f82: 33 23 and r19, r19
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:532
f84: 12 f4 brpl .+4 ; 0xf8a <__mulhisi3+0xa>
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:533
f86: 8a 1b sub r24, r26
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:536
f88: 9b 0b sbc r25, r27
f8a: 10 c0 rjmp .+32 ; 0xfac <__usmulhisi3_tail>
00000f8c <__umulhisi3>:
__umulhisi3():
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:564
f8c: a2 9f mul r26, r18
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:565
f8e: b0 01 movw r22, r0
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:566
f90: b3 9f mul r27, r19
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:567
f92: c0 01 movw r24, r0
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:568
f94: a3 9f mul r26, r19
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:573
f96: 70 0d add r23, r0
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:574
f98: 81 1d adc r24, r1
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:575
f9a: 11 24 eor r1, r1
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:576
f9c: 91 1d adc r25, r1
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:580
f9e: b2 9f mul r27, r18
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:581
fa0: 70 0d add r23, r0
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:582
fa2: 81 1d adc r24, r1
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:583
fa4: 11 24 eor r1, r1
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:584
fa6: 91 1d adc r25, r1
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:585
fa8: 08 95 ret
00000faa <__usmulhisi3>:
__usmulhisi3():
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:545
faa: f0 df rcall .-32 ; 0xf8c <__umulhisi3>
00000fac <__usmulhisi3_tail>:
__usmulhisi3_tail():
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:551
fac: b7 ff sbrs r27, 7
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:552
fae: 08 95 ret
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:553
fb0: 82 1b sub r24, r18
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:554
fb2: 93 0b sbc r25, r19
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:555
fb4: 08 95 ret
00000fb6 <__muluhisi3>:
__muluhisi3():
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:626
fb6: ea df rcall .-44 ; 0xf8c <__umulhisi3>
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:627
fb8: a5 9f mul r26, r21
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:628
fba: 90 0d add r25, r0
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:629
fbc: b4 9f mul r27, r20
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:630
fbe: 90 0d add r25, r0
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:631
fc0: a4 9f mul r26, r20
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:632
fc2: 80 0d add r24, r0
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:633
fc4: 91 1d adc r25, r1
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:634
fc6: 11 24 eor r1, r1
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:635
fc8: 08 95 ret
00000fca <__udivmodsi4>:
__udivmodsi4():
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1638
fca: a1 e2 ldi r26, 0x21 ; 33
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1639
fcc: 1a 2e mov r1, r26
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1640
fce: aa 1b sub r26, r26
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1641
fd0: bb 1b sub r27, r27
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1642
fd2: fd 01 movw r30, r26
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1644
fd4: 0d c0 rjmp .+26 ; 0xff0 <__udivmodsi4_ep>
00000fd6 <__udivmodsi4_loop>:
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1646
fd6: aa 1f adc r26, r26
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1647
fd8: bb 1f adc r27, r27
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1648
fda: ee 1f adc r30, r30
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1649
fdc: ff 1f adc r31, r31
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1650
fde: a2 17 cp r26, r18
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1651
fe0: b3 07 cpc r27, r19
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1652
fe2: e4 07 cpc r30, r20
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1653
fe4: f5 07 cpc r31, r21
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1654
fe6: 20 f0 brcs .+8 ; 0xff0 <__udivmodsi4_ep>
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1655
fe8: a2 1b sub r26, r18
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1656
fea: b3 0b sbc r27, r19
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1657
fec: e4 0b sbc r30, r20
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1658
fee: f5 0b sbc r31, r21
00000ff0 <__udivmodsi4_ep>:
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1660
ff0: 66 1f adc r22, r22
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1661
ff2: 77 1f adc r23, r23
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1662
ff4: 88 1f adc r24, r24
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1663
ff6: 99 1f adc r25, r25
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1664
ff8: 1a 94 dec r1
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1665
ffa: 69 f7 brne .-38 ; 0xfd6 <__udivmodsi4_loop>
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1667
ffc: 60 95 com r22
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1668
ffe: 70 95 com r23
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1669
1000: 80 95 com r24
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1670
1002: 90 95 com r25
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1672
1004: 9b 01 movw r18, r22
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1674
1006: ac 01 movw r20, r24
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1676
1008: bd 01 movw r22, r26
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1678
100a: cf 01 movw r24, r30
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:1680
100c: 08 95 ret
0000100e <_exit>:
exit():
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:2278
100e: f8 94 cli
00001010 <__stop_program>:
__stop_program():
/home/admin/Arduino/toolchain-avr-special-master/gcc-build/avr/avrxmega3/libgcc/../../../../gcc/libgcc/config/avr/lib1funcs.S:2280
1010: ff cf rjmp .-2 ; 0x1010 <__stop_program>
Related Packages
More from this authorgokul/board-v2This design integrates an ESP32-S3 Wi-Fi and Bluetooth module, a USB-C port with power and data circuitry, a USB ESD protection chip, a 3.3V voltage regulator, and an OLED display module on a PCB with associated routing and thermal copper pour layers.
Similar packagemohan-bee/speakerThis code defines configurable 3D models and PCB footprints for various electronic components, including a battery charger IC, a dual Hall sensor, a dual power switch, and a voltage regulator, with detailed pinouts, footprints, and CAD models for schematic and physical design.
Discover something newrushabhcodes/ESP32-E-ReaderThis code defines the physical layout and schematic wiring of an ESP32-based e-reader device, including various surface-mount components such as connectors, ICs, resistors, capacitors, inductors, diodes, pushbuttons, and an antenna, with precise PCB placement and interconnection details.