day5 done

src/plasl/2025/day5/part1.psl

@@ -0,0 +1,162 @@
+
+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() {
+   
+    array i8[65535] set buffer
+    get buffer i8(48) store
+    read(0, get buffer, u64(65535)) as i32 set size
+    #get buffer get size+ i8(10) store
+
+    array u64[256] set lower
+    array u64[256] set higher
+    0 set bounds
+
+    u64(0) `so`
+    `0si`
+
+    while (buffer[`li`] load i8(10) != buffer[`li1+`] load i8(10) != &) {
+        while (buffer[`li`] load i8(10) !=) {
+            
+            lower[get bounds] atol(buffer[`li`]) dup printnum64 store 
+            while (buffer[`li`] load '-' !=) { inc(i) }
+            inc(i) ',' putc
+            higher[get bounds] atol(buffer[`li`]) dup printnum64 store
+            while (buffer[`li`] load i8(10) !=) { inc(i) }
+           
+            inc(bounds)
+
+            inc(i) i8(10) putc
+            
+        }
+    }
+    inc(i)
+    i8(10) putc
+
+    while (get i get size 1- < ) {
+        atol(buffer[`li`]) dup printnum64 `sc`
+        inc(i)
+
+        `0sj`
+        while (`lj` get bounds <) {
+            
+            if (higher[`lj`] load `lc` >= lower[`lj`] load `lc` <= &) {
+                inc(o)
+                'y' putc
+                # poor man's break
+                `lj65535+sj`
+            }
+
+            inc(j)
+        } 
+
+        i8(10) putc
+        
+        while (buffer[`li`] load i8(10) !=) { inc(i) }
+        inc(i)
+    }
+    
+    println("answer:")
+    `lo` printnum64 i8(10) putc
+    exit(0)
+}
+
+void main() {
+    _start
+}

src/plasl/2025/day5/part2.psl

@@ -0,0 +1,226 @@
+
+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() {
+   
+    array i8[65535] set buffer
+    get buffer i8(48) store
+    read(0, get buffer, u64(65535)) as i32 set size
+    #get buffer get size+ i8(10) store
+
+    array u64[256] set lower
+    array u64[256] set higher
+    0 set bounds
+
+    u64(0) `so`
+    `0si`
+
+    while (buffer[`li`] load i8(10) != buffer[`li1+`] load i8(10) != &) {
+        while (buffer[`li`] load i8(10) !=) {
+            
+            lower[get bounds] atol(buffer[`li`]) dup printnum64 store 
+            while (buffer[`li`] load '-' !=) { inc(i) }
+            inc(i) ',' putc
+            higher[get bounds] atol(buffer[`li`]) dup printnum64 store
+            while (buffer[`li`] load i8(10) !=) { inc(i) }
+           
+            inc(bounds)
+
+            inc(i) i8(10) putc
+            
+        }
+    }
+    inc(i)
+    i8(10) putc
+
+    get bounds 1- set j
+    while (`lj` 0 >=) {
+
+        
+        # merge flag
+        u1(0) `sm`
+
+        # check for merge 
+        `ljsk`
+
+        while (`lk1` >= `lm` u1(0) == &) {
+            dec(k)
+            #get j printnum ',' putc get k printnum i8(10) putc
+            if (lower[`lk`] load lower[`lj`] load <=
+                higher[`lk`] load higher[`lj`] load >= &) {
+                # inner merge - do nothing
+
+                println("inner merge") 
+                higher[`lk`] load printnum64 '.' putc lower[`lk`] load printnum64 i8(10) putc
+                higher[`lj`] load printnum64 '.' putc lower[`lj`] load printnum64 i8(10) putc
+
+
+                higher[`lk`] load printnum64 '.' putc lower[`lk`] load printnum64 i8(10) putc
+
+                # flag
+                u1(1) `sm`
+            } else if  (lower[`lk`] load lower[`lj`] load >=
+                higher[`lk`] load higher[`lj`] load <= &) {
+
+                # outer merge, replace that range with this one 
+
+                println("outer merge") 
+                higher[`lk`] load printnum64 '.' putc lower[`lk`] load printnum64 i8(10) putc
+                higher[`lj`] load printnum64 '.' putc lower[`lj`] load printnum64 i8(10) putc
+                
+                higher[`lk`] higher[`lj`] load store
+                lower[`lk`] lower[`lj`] load store
+
+
+                higher[`lk`] load printnum64 '.' putc lower[`lk`] load printnum64 i8(10) putc
+                
+                # flag
+                u1(1) `sm`
+            } else if (lower[`lk`] load higher[`lj`] load <=
+                       lower[`lk`] load lower[`lj`] load >= &) {
+        
+                # left merge, replace bottom with new bottom
+                
+                println("left merge") 
+                higher[`lk`] load printnum64 '.' putc lower[`lk`] load printnum64 i8(10) putc
+                higher[`lj`] load printnum64 '.' putc lower[`lj`] load printnum64 i8(10) putc
+
+                lower[`lk`] lower[`lj`] load store
+
+
+                higher[`lk`] load printnum64 '.' putc lower[`lk`] load printnum64 i8(10) putc
+               
+                u1(1) `sm`
+            } else if (higher[`lk`] load higher[`lj`] load <=
+                       higher[`lk`] load lower[`lj`] load >= &) {
+        
+                # right merge, replace top with new top
+                
+                println("right merge") 
+                higher[`lk`] load printnum64 '.' putc lower[`lk`] load printnum64 i8(10) putc
+                higher[`lj`] load printnum64 '.' putc lower[`lj`] load printnum64 i8(10) putc
+
+                higher[`lk`] higher[`lj`] load store
+               
+                higher[`lk`] load printnum64 '.' putc lower[`lk`] load printnum64 i8(10) putc
+                
+                u1(1) `sm`
+            }
+        }
+
+        # if no merge was performed, or last one 
+        if (`lm` u1(0) ==) {
+            lower[`lj`] load dup printnum64 '-' putc
+            higher[`lj`] load dup printnum64
+
+            # 1+ for the inclusive bounds
+            `r-`u64(1)`+lo+so`
+        }
+
+        dec(j) i8(10) putc
+    }
+    
+    println("answer:")
+    `lo` printnum64 i8(10) putc
+    exit(0)
+}
+
+void main() {
+    _start
+}