1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
|
; Advent of Code 2025 - Day 1
bits 64
default rel
global _start
%include "utils/io.asm"
section .data
input_path db "input/day1.txt", 0
label1 db "Password 1: ", 0
label2 db "Password 2: ", 0
angle1 dd 50
angle2 dd 50
password1 dd 0
password2 dd 0
section .bss
buffer resb 4096
line_buffer resb 256
line_len resd 1
section .text
_start:
; open file
mov rax, SYS_OPEN
mov rdi, input_path
mov rsi, O_RDONLY
xor rdx, rdx
syscall
mov r12, rax ; fd in R12
mov dword [line_len], 0 ; no chars in current line yet
read_loop:
; read up to 4096 bytes
mov rax, SYS_READ
mov rdi, r12
mov rsi, buffer
mov rdx, 4096
syscall
cmp rax, 0
jle eof ; <=0 -> EOF or error
mov rdi, buffer ; scan pointer
mov rbp, rax ; bytes remaining in this chunk
scan_chunk:
cmp rbp, 0
je read_loop ; chunk done, read next
mov al, [rdi]
; windows can be a fucking bitch
; handle (CR) -> just skip
cmp al, 13
je skip_cr
; handle LF (10) -> end of line
cmp al, 10
je end_of_line
; normal character -> append to line_buffer if space left
mov edx, [line_len]
cmp edx, 255 ; leave 1 byte for NULL
jae skip_store ; ignore extra characters if too long
mov [line_buffer+rdx], al
inc edx
mov [line_len], edx
skip_store:
inc rdi
dec rbp
jmp scan_chunk
skip_cr:
inc rdi
dec rbp
jmp scan_chunk
end_of_line:
; terminate current line
mov edx, [line_len]
mov byte [line_buffer+rdx], 0
; if line isn't empty, process it
cmp edx, 0
je line_done
push rdi
mov rsi, line_buffer
call handle_line
pop rdi
line_done:
mov dword [line_len], 0 ; reset line length
inc rdi
dec rbp
jmp scan_chunk
; process last line if not newline-terminated, then print result
eof:
; if there is a partial line at EOF, process it
mov edx, [line_len]
cmp edx, 0
jle print_results
mov byte [line_buffer+rdx], 0
mov rsi, line_buffer
call handle_line
print_results:
mov rcx, label1
call print_string
mov eax, [password1]
call print_int64
call print_newline
mov rcx, label2
call print_string
mov eax, [password2]
call print_int64
call print_newline
mov rax, SYS_CLOSE
mov rdi, r12
syscall
mov rax, SYS_EXIT
xor rdi, rdi
syscall
; Handle one line: RSI -> "L123" or "R45"
handle_line:
mov al, [rsi]
cmp al, 'L'
je .left
mov ebx, 1 ; direction = +1 for 'R' or anything else
jmp .after
.left:
mov ebx, -1 ; direction = -1 for 'L'
.after:
inc rsi ; skip 'L' or 'R'
call parse_int ; EAX = steps
mov ecx, eax
; Part 1
p1_start:
mov eax, ecx
imul eax, ebx
add eax, [angle1]
call normalize_angle
mov [angle1], eax
cmp eax, 0
jne p2_start
mov rdi, password1
mov edx, [rdi]
inc edx
mov [rdi], edx
; Part 2
p2_start:
mov rdi, password2
.loop:
test ecx, ecx
jle p2_exit
dec ecx
mov eax, [angle2]
call update_angle_count
mov [angle2], eax
jmp .loop
p2_exit:
ret
; normalize eax to 0..99
normalize_angle:
cmp eax, 0
jl .add
cmp eax, 100
jl .done
sub eax, 100
jmp normalize_angle
.add:
add eax, 100
jmp normalize_angle
.done:
ret
; eax = angle, ebx = direction, rdi = password counter addr
update_angle_count:
add eax, ebx
call normalize_angle
cmp eax, 0
jne .done
mov edx, [rdi]
inc edx
mov [rdi], edx
.done:
ret
; parse ASCII integer into EAX
parse_int:
xor eax, eax ; result = 0
.parse_loop:
mov dl, [rsi]
cmp dl, '0'
jl .done
cmp dl, '9'
jg .done
sub dl, '0' ; digit value 0..9
movzx edx, dl
imul eax, eax, 10 ; result *= 10
add eax, edx ; result += digit
inc rsi
jmp .parse_loop
.done:
ret
|
