adventofcode/src/plasl/2025/day4/part2.psl

i64 write(i32, ptr i8, u64) {
    `scsbsa`
    syscall3(i64(1), `la` as i64, `lb` as i64, `lc` as i64)
}

i64 read(i32, ptr i8, u64) {
    `scsbsa`
    syscall3(i64(0), `la` as i64, `lb` as i64, `lc` as i64)
}

i32 open(ptr i8, i32, i32) { 
    `scsbsa`
    syscall3(i64(2), `la` as i64, `lb` as i64, `lc` as i64)
    as i32
}

void exit(i32) {
    as i64 i64(231) rev
    syscall1 trash
}

void putc(i8) {
    array i8[1] `dstr` store 
    write(1, `lt`, u64(1)) trash
}

u64 strlen(ptr i8) {
    dup while(dup load i8(0) !=) { 1+ } `r-`
}

void print(ptr i8) {
    1 rev dup strlen write trash
}

void println(ptr i8) {
    print i8(10) putc
}

void printnum(i32) {
 
    if (dup 0 ==) {
        putc('0')
    } else if (dup 0 <) {
        `0r-` '-' putc
    }

    array i8[11] 10+ dup i8(0) store -1+ `sb`

    while (dup 0 !=) {
        10 divmod 48+ as i8 
        `lb` rev store 
        `lb` -1+ `sb`
    } trash
    print(`lb`1+)

}

void printnum64(u64) {
 
    if (dup u64(0) ==) {
        putc('0')
    } 

    array i8[22] 22+ dup i8(0) store -1+ `sb`

    while (dup u64(0) !=) {
        u64(10) divmod u64(48)+ as i8 
        `lb` rev store 
        `lb` -1+ `sb`
    } trash

    print(`lb`1+)

}

i32 atoi(ptr i8) {
    set string
    0
    while (get string load '0' >= get string load '9' <= &) {
        10* get string load '0'- as i32 +
        get string 1+ set string
    }
}

u64 atol(ptr i8) {
    set string
    u64(0)
    while (get string load '0' >= get string load '9' <= &) {
        u64(10)* get string load '0'- as u64 +
        get string 1+ set string
    }
}


i32 abs(i32) {
    if (dup 0 <) {`0r-`}
}

void _start() {
   
    open("example.txt", 0, 0) set file
    array i8[65535] set buffer
    get buffer i8(48) store
    read(get file, get buffer, u64(65535)) as i32 set size
    #get buffer get size+ -1+ i8(10) store

    u64(1) `sO`
    u64(0) `so`
    0 set i

    while (buffer[`li`] load i8(10) !=) {
        inc(i)
    }

    `lid1+swsh`

    while (`lOlo` !=) {

        `losO`

        `0si`
        while (get i get size < ) {
           
            if (buffer[`li`] load '@' ==) {
            
                if (`li0`==) {
                    # tl corner
                    # buffer[1] load '@' == as i32
                    # buffer[`lw`] load '@' == as i32
                    # buffer[`lw1+`] load '@' == as i32
                    # +++
                    0 # this is always valid
                } else if (`lilw2-`==) {
                    # tr corner 
                    # buffer[`lw2-`] load '@' == as i32 
                    # buffer[`lw2*1-`] load '@' == as i32
                    # buffer[`lw2*1-`] load '@' == as i32
                    0 
                } else if (`li``lwlh*lw-`==) {
                    #bl corner
                    0
                } else if (`li``lwlh*2-`==) {
                    # br corner
                    0
                } else if (`lilw` <) {
                    # t edge
                    buffer[`li1-`] load '@' == as i32
                    buffer[`li1+`] load '@' == as i32
                    
                    buffer[`lilw+1-`] load '@' == as i32
                    buffer[`lilw+`] load '@' == as i32
                    buffer[`lilw+1+`] load '@' == as i32

                    ++++

                } else if (`lilwlh*lw-` >){
                    # b edge

                    buffer[`lilw-1-`] load '@' == as i32
                    buffer[`lilw-`] load '@' == as i32
                    buffer[`lilw-1+`] load '@' == as i32
                    
                    buffer[`li1-`] load '@' == as i32
                    buffer[`li1+`] load '@' == as i32
                    
                    ++++

                } else if (`lilw`%0==) {
                    # l edge

                    buffer[`lilw-`] load '@' == as i32
                    buffer[`lilw-1+`] load '@' == as i32
                    
                    buffer[`li1+`] load '@' == as i32
                    
                    buffer[`lilw+`] load '@' == as i32
                    buffer[`lilw+1+`] load '@' == as i32

                    ++++

                } else if (`lilw`%`lw2-`==) {
                    # r edge

                    buffer[`lilw-1-`] load '@' == as i32
                    buffer[`lilw-`] load '@' == as i32
                    
                    buffer[`li1-`] load '@' == as i32
                    
                    buffer[`lilw+1-`] load '@' == as i32
                    buffer[`lilw+`] load '@' == as i32

                    ++++
                } else {
                    
                    buffer[`lilw-1-`] load '@' == as i32
                    buffer[`lilw-`] load '@' == as i32
                    buffer[`lilw-1+`] load '@' == as i32
                    
                    buffer[`li1-`] load '@' == as i32
                    buffer[`li1+`] load '@' == as i32
                    
                    buffer[`lilw+1-`] load '@' == as i32
                    buffer[`lilw+`] load '@' == as i32
                    buffer[`lilw+1+`] load '@' == as i32
                    
                    +++++++

                }

                if ( 4 < ) {
                    inc(o)
                    buffer[`li`] 'x' store
                } 

            } 

            inc(i)

        }

        # yeah !
        `0si`

        print(get buffer)

        while (get i get size < ) {
            if (buffer[`li`] load 'x' ==) { buffer[`li`] '.' store }
            inc(i)
        }

        printnum64(`lolO-`) i8(10) putc
        i8(10) putc

    }


    println("answer:")
    `lo` printnum64 i8(10) putc
    exit(0)
}

void main() {
    _start
}