chore: refactor repository

4 files changed, 0 insertions, 1050 deletions

diff --git a/src/Day1.asm b/src/Day1.asm
deleted file mode 100644
index 8ba8f0e..0000000
--- a/src/Day1.asm
+++ /dev/null
@@ -1,314 +0,0 @@
-; Advent of Code 2025 - Day 1

-

-bits 64

-default rel

-

-global _start

-

-%define SYS_EXIT   60

-%define SYS_READ   0

-%define SYS_WRITE  1

-%define SYS_OPEN   2

-%define SYS_CLOSE  3

-

-%define O_RDONLY   0

-%define STDOUT     1

-

-section .data

-    inputPath db "input/day1.txt", 0

-    newline   db 10

-

-    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

-    lineBuffer   resb 256

-    numberBuffer resb 16

-    lineLen      resd 1

-

-section .text

-

-_start:

-    ; open file

-    mov     rax, SYS_OPEN

-    mov     rdi, inputPath

-    mov     rsi, O_RDONLY

-    xor     rdx, rdx

-    syscall

-

-    mov     r12, rax           ; fd in R12

-    mov     dword [lineLen], 0 ; no chars in current line yet

-

-ReadLoop:

-    ; 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

-

-ScanChunk:

-    cmp     rbp, 0

-    je      ReadLoop ; chunk done, read next

-

-    mov     al, [rdi]

-

-    ; windows can be a fucking bitch

-    ; handle (CR) -> just skip

-    cmp     al, 13

-    je      SkipCR

-

-    ; handle LF (10) -> end of line

-    cmp     al, 10

-    je      EndOfLine

-

-    ; normal character -> append to lineBuffer if space left

-    mov     edx, [lineLen]

-    cmp     edx, 255  ; leave 1 byte for NULL

-    jae     SkipStore ; ignore extra characters if too long

-    mov     [lineBuffer+rdx], al

-    inc     edx

-    mov     [lineLen], edx

-

-SkipStore:

-    inc     rdi

-    dec     rbp

-    jmp     ScanChunk

-

-SkipCR:

-    inc     rdi

-    dec     rbp

-    jmp     ScanChunk

-

-EndOfLine:

-    ; terminate current line

-    mov     edx, [lineLen]

-    mov     byte [lineBuffer+rdx], 0

-

-    ; if line isn't empty, process it

-    cmp     edx, 0

-    je      LineDone

-

-    push    rdi

-    mov     rsi, lineBuffer

-    call    HandleLine

-    pop     rdi

-

-LineDone:

-    mov     dword [lineLen], 0 ; reset line length

-    inc     rdi

-    dec     rbp

-    jmp     ScanChunk

-

-; process last line if not newline-terminated, then print result

-EOF:

-    ; if there is a partial line at EOF, process it

-    mov     edx, [lineLen]

-    cmp     edx, 0

-    jle     PrintResults

-    mov     byte [lineBuffer+rdx], 0

-

-    mov     rsi, lineBuffer

-    call    HandleLine

-

-PrintResults:

-    mov     rcx, label1

-    call    PrintString

-    mov     eax, [password1]

-    call    PrintInt

-

-    ; newline

-    mov     rax, SYS_WRITE

-    mov     rdi, STDOUT

-    mov     rsi, newline

-    mov     rdx, 1

-    syscall

-

-    mov     rcx, label2

-    call    PrintString

-    mov     eax, [password2]

-    call    PrintInt

-

-    ; new linhe

-    mov     rax, SYS_WRITE

-    mov     rdi, STDOUT

-    mov     rsi, newline

-    mov     rdx, 1

-    syscall

-

-    mov     rax, SYS_CLOSE

-    mov     rdi, r12

-    syscall

-    mov     rax, SYS_EXIT

-    xor     rdi, rdi

-    syscall

-

-; Handle one line: RSI -> "L123" or "R45"

-HandleLine:

-    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    ParseInt ; EAX = steps

-    mov     ecx, eax

-

-; Part 1

-P1_Start:

-    mov     eax, ecx

-    imul    eax, ebx

-    add     eax, [angle1]

-    call    NormalizeAngle

-    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    UpdateAngleCount

-    mov     [angle2], eax

-

-    jmp     .loop

-P2_Exit:

-    ret

-

-; normalize eax to 0..99

-NormalizeAngle:

-    cmp     eax, 0

-    jl      .add

-    cmp     eax, 100

-    jl      .done

-    sub     eax, 100

-    jmp     NormalizeAngle

-.add:

-    add     eax, 100

-    jmp     NormalizeAngle

-.done:

-    ret

-

-; eax = angle, ebx = direction, rdi = password counter addr

-UpdateAngleCount:

-    add     eax, ebx

-    call    NormalizeAngle

-

-    cmp     eax, 0

-    jne     .done

-    mov     edx, [rdi]

-    inc     edx

-    mov     [rdi], edx

-.done:

-    ret

-

-; parse ASCII integer into EAX

-ParseInt:

-    xor     eax, eax     ; result = 0

-.parseLoop:

-    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     .parseLoop

-.done:

-    ret

-

-PrintInt:

-    mov     edi, numberBuffer+15 ; write digits from the end

-    mov     byte [rdi], 0        ; terminator

-    dec     rdi

-

-    cmp     eax, 0

-    jne     .convert

-    mov     byte [rdi], '0'

-    jmp     .finish

-.convert:

-    ; we will repeatedly compute:

-    ;   q = eax / 10

-    ;   r = eax % 10

-    ; using only subtraction

-.nextDigit:

-    mov     edx, eax   ; tmp = current value

-    mov     ecx, 0     ; q = 0

-

-    cmp     edx, 10    ; if < 0,  q=0, r=edx

-    jb      .lastDigit

-.subLoop:

-    sub     edx, 10

-    inc     ecx        ; q++

-    cmp     edx, 10

-    jae     .subLoop   ; while tmp >= 10

-.lastDigit:

-    ; now:

-    ;   ecx = quotient

-    ;   edx = remainder (0..9)

-    add     dl, '0'

-    mov     [rdi], dl  ; store digit

-    dec     rdi

-    mov     eax, ecx   ; eax = quotient

-    test    eax, eax

-    jnz     .nextDigit ; more digits to extract?

-

-    inc     rdi        ; move to first digit

-.finish:

-    mov     rax, SYS_WRITE

-    mov     rsi, rdi              ; buffer pointer

-    mov     rdi, STDOUT

-    mov     rdx, numberBuffer+15

-    sub     rdx, rsi              ; length

-    syscall

-    ret

-

-PrintString:

-    push    rcx

-    push    rdx

-    mov     rdx, 0

-.count:

-    cmp     byte [rcx+rdx], 0

-    je      .doneCount

-    inc     rdx

-    jmp     .count

-.doneCount:

-    mov     rax, SYS_WRITE

-    mov     rdi, STDOUT

-    mov     rsi, rcx

-    syscall

-

-    pop     rdx

-    pop     rcx

-    ret

diff --git a/src/Day2.asm b/src/Day2.asm
deleted file mode 100644
index dfbfb38..0000000
--- a/src/Day2.asm
+++ /dev/null
@@ -1,410 +0,0 @@
-; Advent of Code 2025 – Day 2
-
-bits 64
-default rel
-
-global _start
-
-%define SYS_EXIT   60
-%define SYS_READ   0
-%define SYS_WRITE  1
-%define SYS_OPEN   2
-%define SYS_CLOSE  3
-
-%define O_RDONLY   0
-%define STDOUT     1
-
-section .data
-    inputPath db "input/day2.txt", 0
-    newline   db 10
-
-    label1 db "Part 1: ", 0
-    label2 db "Part 2: ", 0
-
-section .bss
-    buffer       resb 4096
-    lineBuffer   resb 65536
-    lineLen      resd 1
-
-    sum1         resq 1
-    sum2         resq 1
-
-    numberBuffer resb 32     ; for printing and NumberToString
-
-section .text
-
-_start:
-    mov     rax, SYS_OPEN
-    mov     rdi, inputPath
-    mov     rsi, O_RDONLY
-    xor     rdx, rdx
-    syscall
-
-    mov     r12, rax                 ; file descriptor
-    mov     dword [lineLen], 0
-
-ReadLoop:
-    mov     rax, SYS_READ
-    mov     rdi, r12
-    mov     rsi, buffer
-    mov     rdx, 4096
-    syscall
-
-    cmp     rax, 0
-    jle     EOF
-
-    mov     rdi, buffer
-    mov     rbp, rax
-
-ScanChunk:
-    cmp     rbp, 0
-    je      ReadLoop
-
-    mov     al, [rdi]
-
-    cmp     al, 13
-    je      SkipCR
-
-    cmp     al, 10
-    je      EndLine
-
-    mov     edx, [lineLen]
-    cmp     edx, 65535
-    jae     SkipStore
-    mov     [lineBuffer+rdx], al
-    inc     edx
-    mov     [lineLen], edx
-
-SkipStore:
-    inc     rdi
-    dec     rbp
-    jmp     ScanChunk
-
-SkipCR:
-    inc     rdi
-    dec     rbp
-    jmp     ScanChunk
-
-EndLine:
-    mov     edx, [lineLen]
-    mov     byte [lineBuffer+rdx], 0
-
-    cmp     edx, 0
-    je      ClearLine
-
-    push    rdi
-    mov     rsi, lineBuffer
-    call    HandleLine
-    pop     rdi
-
-ClearLine:
-    mov     dword [lineLen], 0
-    inc     rdi
-    dec     rbp
-    jmp     ScanChunk
-
-EOF:
-    ; process final partial line if needed
-    mov     edx, [lineLen]
-    cmp     edx, 0
-    jle     PrintResults
-
-    mov     byte [lineBuffer+rdx], 0
-    mov     rsi, lineBuffer
-    call    HandleLine
-
-PrintResults:
-    mov     rcx, label1
-    call    PrintString
-    mov     rax, [sum1]
-    call    PrintInt64
-    call    Newline
-
-    mov     rcx, label2
-    call    PrintString
-    mov     rax, [sum2]
-    call    PrintInt64
-    call    Newline
-
-    mov     rax, SYS_CLOSE
-    mov     rdi, r12
-    syscall
-
-    mov     rax, SYS_EXIT
-    xor     rdi, rdi
-    syscall
-
-; parse "A-B,C-D,..."l, RSI = pointer to line
-; uses r13 = current ID, r14 = end of range
-HandleLine:
-NextRange:
-    ; parse start
-    call    ParseInt64
-    mov     r13, rax
-
-    cmp     byte [rsi], '-'
-    jne     DoneLine
-    inc     rsi
-
-    ; parse end
-    call    ParseInt64
-    mov     r14, rax
-
-RangeLoop:
-    cmp     r13, r14
-    jg      AfterRange
-
-    ; Save RSI (line pointer) across the checks,
-    ; because NumberToString / CheckInvalid* use RSI
-    push    rsi
-
-    ; Part 1: exact AA
-    mov     rax, r13
-    call    CheckInvalid1
-    test    rax, rax
-    jz      .skipP1
-    add     qword [sum1], r13
-.skipP1:
-    ; Part 2: any repeating block >= 2
-    mov     rax, r13
-    call    CheckInvalid2
-    test    rax, rax
-    jz      .skipP2
-    add     qword [sum2], r13
-.skipP2:
-    pop     rsi ; restore line pointer
-
-    inc     r13
-    jmp     RangeLoop
-
-AfterRange:
-    cmp     byte [rsi], ','
-    jne     DoneLine
-    inc     rsi
-    jmp     NextRange
-
-DoneLine:
-    ret
-
-; RSI points at decimal digits; stops on first non-digit
-ParseInt64:
-    xor     rax, rax
-.parse:
-    mov     dl, [rsi]
-    cmp     dl, '0'
-    jl      .done
-    cmp     dl, '9'
-    jg      .done
-
-    sub     dl, '0'
-    movzx   rdx, dl
-    imul    rax, rax, 10
-    add     rax, rdx
-
-    inc     rsi
-    jmp     .parse
-.done:
-    ret
-
-; NumberToString: convert RAX to decimal ASCII, MSB-first
-;   Output:
-;     RSI = pointer to first digit
-;     ECX = length
-NumberToString:
-    mov     rdi, numberBuffer+31
-    mov     byte [rdi], 0        ; terminator (for convenience)
-    dec     rdi
-
-    cmp     rax, 0
-    jne     .conv
-
-    ; handle zero
-    mov     byte [rdi], '0'
-    mov     rsi, rdi
-    mov     ecx, 1
-    ret
-
-.conv:
-    mov     rbx, 10
-.nextDigit:
-    xor     rdx, rdx
-    div     rbx                  ; RAX = quotient, RDX = remainder
-    add     dl, '0'
-    mov     [rdi], dl
-    dec     rdi
-    test    rax, rax
-    jnz     .nextDigit
-
-    inc     rdi                  ; now RDI points to first digit
-    mov     rsi, rdi
-    mov     rdx, numberBuffer+31
-    sub     rdx, rsi             ; RDX = length
-    mov     ecx, edx
-    ret
-
-; CheckInvalid1: "AA" pattern
-;   RAX = number
-;   Returns RAX = 1 if digits == A A, else 0
-CheckInvalid1:
-    push    rbx
-    push    rdx
-
-    call    NumberToString       ; RSI=string, ECX=len
-    mov     eax, ecx             ; EAX = len
-
-    cmp     eax, 2
-    jl      .no1
-
-    test    eax, 1
-    jnz     .no1                 ; odd length => cannot be AA
-
-    shr     eax, 1               ; half = len/2
-    mov     r8d, eax             ; half
-    xor     r9d, r9d             ; i = 0
-
-.loop1:
-    cmp     r9d, r8d
-    jge     .yes1
-
-    ; s[i]
-    mov     rdx, r9
-    movzx   eax, byte [rsi + rdx]
-
-    ; s[i+half]
-    mov     rdx, r9
-    add     rdx, r8
-    movzx   ebx, byte [rsi + rdx]
-
-    cmp     eax, ebx
-    jne     .no1
-
-    inc     r9d
-    jmp     .loop1
-
-.yes1:
-    mov     rax, 1
-    jmp     .ret1
-
-.no1:
-    xor     rax, rax
-
-.ret1:
-    pop     rdx
-    pop     rbx
-    ret
-
-; CheckInvalid2: any repeating block >= 2
-;   RAX = number
-;   Returns RAX = 1 if string is some A repeated k>=2 times
-CheckInvalid2:
-    push    rbx
-    push    rdx
-
-    call    NumberToString       ; RSI=string, ECX=len
-    mov     r11d, ecx            ; n = length
-
-    cmp     r11d, 2
-    jb      .no2
-
-    mov     r8d, 1               ; m = 1 (candidate period)
-.outer:
-    cmp     r8d, r11d
-    jge     .no2
-
-    ; if n % m != 0 => cannot tile
-    mov     eax, r11d
-    xor     edx, edx
-    div     r8d                  ; EAX=q, EDX=r
-    test    edx, edx
-    jnz     .next_m
-
-    mov     r9d, r11d
-    sub     r9d, r8d             ; limit = n - m
-    xor     r10d, r10d           ; i = 0
-.inner:
-    cmp     r10d, r9d
-    jge     .yes2                ; all positions checked
-
-    ; s[i]
-    mov     rdx, r10
-    movzx   eax, byte [rsi + rdx]
-
-    ; s[i+m]
-    mov     rdx, r10
-    add     rdx, r8
-    movzx   ebx, byte [rsi + rdx]
-
-    cmp     eax, ebx
-    jne     .next_m
-
-    inc     r10d
-    jmp     .inner
-.yes2:
-    mov     rax, 1
-    jmp     .ret2
-.next_m:
-    inc     r8d
-    jmp     .outer
-.no2:
-    xor     rax, rax
-.ret2:
-    pop     rdx
-    pop     rbx
-    ret
-
-Newline:
-    mov     rax, SYS_WRITE
-    mov     rdi, STDOUT
-    mov     rsi, newline
-    mov     rdx, 1
-    syscall
-    ret
-
-PrintInt64:
-    mov     rdi, numberBuffer+31
-    mov     byte [rdi], 0
-    dec     rdi
-
-    cmp     rax, 0
-    jne     .conv
-
-    mov     byte [rdi], '0'
-    jmp     .done
-.conv:
-    mov     rbx, 10
-.next:
-    xor     rdx, rdx
-    div     rbx
-    add     dl, '0'
-    mov     [rdi], dl
-    dec     rdi
-    test    rax, rax
-    jnz     .next
-
-    inc     rdi
-.done:
-    mov     rax, SYS_WRITE
-    mov     rsi, rdi
-    mov     rdi, STDOUT
-    mov     rdx, numberBuffer+31
-    sub     rdx, rsi
-    syscall
-    ret
-
-PrintString:
-    push    rcx
-    push    rdx
-    mov     rdx, 0
-.length:
-    cmp     byte [rcx+rdx], 0
-    je      .submit
-    inc     rdx
-    jmp     .length
-.submit:
-    mov     rax, SYS_WRITE
-    mov     rdi, STDOUT
-    mov     rsi, rcx
-    syscall
-    pop     rdx
-    pop     rcx
-    ret
diff --git a/src/Day3.asm b/src/Day3.asm
deleted file mode 100644
index e547475..0000000
--- a/src/Day3.asm
+++ /dev/null
@@ -1,301 +0,0 @@
-; Advent of Code 2025 - Day 3
-
-bits 64
-default rel
-
-global _start
-
-%define SYS_EXIT   60
-%define SYS_READ   0
-%define SYS_WRITE  1
-%define SYS_OPEN   2
-%define SYS_CLOSE  3
-
-%define O_RDONLY   0
-%define STDOUT     1
-
-section .data
-    inputPath db "input/day3.txt", 0
-
-    newline   db 10
-
-    label1 db "Part 1: ", 0
-    label2 db "Part 2: ", 0
-
-section .bss
-    buffer       resb 4096
-    lineBuffer   resb 65536
-    lineLen      resd 1
-
-    sum1         resq 1
-    sum2         resq 1
-
-    workDigits   resb 64        ; stack for greedy subsequence
-    numberBuffer resb 32        ; for printing
-
-section .text
-
-_start:
-    mov     rax, SYS_OPEN
-    mov     rdi, inputPath
-    mov     rsi, O_RDONLY
-    xor     rdx, rdx
-    syscall
-
-    mov     r12, rax                 ; fd
-    mov     dword [lineLen], 0
-
-ReadLoop:
-    mov     rax, SYS_READ
-    mov     rdi, r12
-    mov     rsi, buffer
-    mov     rdx, 4096
-    syscall
-
-    cmp     rax, 0
-    jle     EOF
-
-    mov     rdi, buffer
-    mov     rbp, rax
-
-ScanChunk:
-    cmp     rbp, 0
-    je      ReadLoop
-
-    mov     al, [rdi]
-
-    cmp     al, 13
-    je      SkipCR
-
-    cmp     al, 10
-    je      EndLine
-
-    mov     edx, [lineLen]
-    cmp     edx, 65535
-    jae     SkipStore
-    mov     [lineBuffer+rdx], al
-    inc     edx
-    mov     [lineLen], edx
-
-SkipStore:
-    inc     rdi
-    dec     rbp
-    jmp     ScanChunk
-
-SkipCR:
-    inc     rdi
-    dec     rbp
-    jmp     ScanChunk
-
-EndLine:
-    mov     edx, [lineLen]
-    mov     byte [lineBuffer+edx], 0
-
-    cmp     edx, 0
-    je      ClearLine
-
-    push    rdi
-    mov     rsi, lineBuffer
-    call    HandleLine
-    pop     rdi
-
-ClearLine:
-    mov     dword [lineLen], 0
-    inc     rdi
-    dec     rbp
-    jmp     ScanChunk
-
-EOF:
-    ; possible last partial line
-    mov     edx, [lineLen]
-    cmp     edx, 0
-    jle     PrintResults
-
-    mov     byte [lineBuffer+edx], 0
-    mov     rsi, lineBuffer
-    call    HandleLine
-
-PrintResults:
-    mov     rcx, label1
-    call    PrintString
-    mov     rax, [sum1]
-    call    PrintInt64
-    call    Newline
-
-    mov     rcx, label2
-    call    PrintString
-    mov     rax, [sum2]
-    call    PrintInt64
-    call    Newline
-
-    mov     rax, SYS_CLOSE
-    mov     rdi, r12
-    syscall
-
-    mov     rax, SYS_EXIT
-    xor     rdi, rdi
-    syscall
-
-HandleLine:
-    mov     rdi, rsi
-    xor     ecx, ecx              ; ECX = 0
-.lengthLoop:
-    mov     al, [rdi+rcx]
-    cmp     al, 0
-    je      .lengthDone
-    inc     ecx
-    jmp     .lengthLoop
-.lengthDone:
-    mov     r15d, ecx             ; r15d = n
-
-    ; part 1: k = 2
-    mov     ecx, r15d             ; ECX = n
-    mov     edi, 2                ; K = 2
-    call    GetMaxForK            ; RAX = best 2-digit value
-    add     qword [sum1], rax
-
-    ; part 2: k = 12, only if n >= 12
-    cmp     r15d, 12
-    jl      .skipPart2
-
-    mov     ecx, r15d
-    mov     edi, 12
-    call    GetMaxForK            ; RAX = best 12-digit value
-    add     qword [sum2], rax
-
-.skipPart2:
-    ret
-
-; Greedy lexicographically largest subsequence of length K
-;
-; Input:
-;   RSI -> digits string
-;   ECX = n (length)
-;   EDI = k
-; Output:
-;   RAX = numeric value of chosen k digits
-; Clobbers: R8..R11, EAX, EDX
-GetMaxForK:
-    ; dropsRemaining = n - k
-    mov     eax, ecx
-    sub     eax, edi
-    mov     r8d, eax              ; r8d = drops
-
-    xor     r9d, r9d              ; r9d = stackSize
-    xor     r10d, r10d            ; r10d = i
-
-.loop:
-    cmp     r10d, ecx
-    jge     .after_input
-
-    ; current digit in AL
-    mov     r11, r10
-    mov     al, [rsi + r11]
-
-.pop:
-    cmp     r9d, 0
-    jle     .push
-    cmp     r8d, 0
-    jle     .push
-
-    mov     edx, r9d
-    dec     edx
-    mov     r11d, edx
-    mov     bl, [workDigits + r11]
-
-    cmp     bl, al
-    jge     .push
-
-    dec     r9d
-    dec     r8d
-    jmp     .pop
-.push:
-    mov     r11d, r9d
-    mov     [workDigits + r11], al
-    inc     r9d
-    inc     r10d
-    jmp     .loop
-
-.after_input:
-    ; trim if stackSize > k
-.trim:
-    cmp     r9d, edi
-    jle     .convert
-    dec     r9d
-    jmp     .trim
-.convert:
-    xor     rax, rax
-    xor     r11d, r11d
-.convertLoop:
-    cmp     r11d, edi
-    jge     .done
-
-    mov     rdx, r11
-    mov     dl, [workDigits + rdx]
-    sub     dl, '0'
-    movzx   rdx, dl
-
-    imul    rax, rax, 10
-    add     rax, rdx
-
-    inc     r11d
-    jmp     .convertLoop
-.done:
-    ret
-
-Newline:
-    mov     rax, SYS_WRITE
-    mov     rdi, STDOUT
-    mov     rsi, newline
-    mov     rdx, 1
-    syscall
-    ret
-
-PrintInt64:
-    mov     rdi, numberBuffer+31
-    mov     byte [rdi], 0
-    dec     rdi
-
-    cmp     rax, 0
-    jne     .conv
-
-    mov     byte [rdi], '0'
-    jmp     .done
-.conv:
-    mov     rbx, 10
-.next:
-    xor     rdx, rdx
-    div     rbx
-    add     dl, '0'
-    mov     [rdi], dl
-    dec     rdi
-    test    rax, rax
-    jnz     .next
-
-    inc     rdi
-.done:
-    mov     rax, SYS_WRITE
-    mov     rsi, rdi
-    mov     rdi, STDOUT
-    mov     rdx, numberBuffer+31
-    sub     rdx, rsi
-    syscall
-    ret
-
-PrintString:
-    push    rcx
-    push    rdx
-    mov     rdx, 0
-.length:
-    cmp     byte [rcx+rdx], 0
-    je      .submit
-    inc     rdx
-    jmp     .length
-.submit:
-    mov     rax, SYS_WRITE
-    mov     rdi, STDOUT
-    mov     rsi, rcx
-    syscall
-    pop     rdx
-    pop     rcx
-    ret
diff --git a/src/Day4.asm b/src/Day4.asm
deleted file mode 100644
index 475f2ef..0000000
--- a/src/Day4.asm
+++ /dev/null
@@ -1,25 +0,0 @@
-bits 64
-default rel
-
-global _start
-
-%define SYS_EXIT  60
-%define SYS_WRITE 1
-
-%define STDOUT 1
-
-section .data
-    message db "Hello Day 4!", 0xA
-    length  equ $-message
-
-section .text
-_start:
-    mov rax, SYS_WRITE
-    mov rdi, STDOUT
-    mov rsi, message
-    mov rdx, length
-    syscall
-
-    mov rax, SYS_EXIT
-    xor rdi, rdi
-    syscall