plasl day2p1 and a lot of other junk i never pushed

src/c/2024/day16/part1.c

@@ -0,0 +1,146 @@
+#include <stdio.h>
+#include <string.h>
+
+#define BOARD_SIZE 71
+#define NUM_BYTES 1024
+
+#define WALL 10005
+
+#define IN_BOUND(x, y) (x < BOARD_SIZE && x >= 0 && y < BOARD_SIZE && y >= 0)
+#define MIN(a,b) (((a)<(b))?(a):(b))
+
+struct coordinate {
+
+    int x, y;
+
+};
+
+
+struct coordinate queue[10000];
+int queue_len;
+int queue_start;
+
+char map[BOARD_SIZE][BOARD_SIZE];
+int values[BOARD_SIZE][BOARD_SIZE];
+
+
+int queue_pop(struct coordinate *coord) {
+
+    if (queue_len == 0) {
+        return -1;
+    }
+
+    memcpy(coord, &queue[queue_start], sizeof(struct coordinate));
+
+    queue_start++;
+    queue_len--;
+
+    return 0;
+
+}
+
+
+void queue_push(struct coordinate *coord) {
+
+    
+    //printf("%d, %da\n", coord->x, coord->y);
+
+    memcpy(&queue[queue_start + queue_len], coord, sizeof(struct coordinate));
+    queue_len++;
+
+}
+
+
+void check_and_push(struct coordinate *coord, int depth) {
+
+    //printf("%d\n", depth);
+
+    if (!IN_BOUND(coord->x, coord->y) || values[coord->x][coord->y] == WALL) {
+        return;
+    }
+
+    if (values[coord->x][coord->y] == 100000) {
+        //printf("%d\n", depth);
+        values[coord->x][coord->y] = depth + 1;
+        queue_push(coord);
+
+    }
+
+
+}
+
+int dfs(struct coordinate coord) {
+
+    queue_push(&coord);
+    values[coord.x][coord.y] = 0;
+
+    while (!queue_pop(&coord)) {
+
+        int value = values[coord.x][coord.y];
+
+        //printf("%d, %d: %d\n", coord.x, coord.y, values[coord.x][coord.y]);
+
+        if (coord.x == BOARD_SIZE - 1 && coord.y == BOARD_SIZE - 1) {
+            break;
+        }
+
+        coord.x++;
+        check_and_push(&coord, value);
+        coord.x -= 2;
+        check_and_push(&coord, value);
+        coord.x++;
+
+        coord.y++;
+        check_and_push(&coord, value);
+        coord.y -= 2;
+        check_and_push(&coord, value);
+        coord.y++;
+
+
+    }
+
+    return values[BOARD_SIZE - 1][BOARD_SIZE - 1];
+}
+
+
+
+int main() {
+
+    char *line_buf = NULL;
+    size_t buffer_size = 100;
+
+    for (int i = 0; i < BOARD_SIZE; i++) {
+        for (int j = 0; j < BOARD_SIZE; j++) {
+            map[i][j] = '.';
+            values[i][j] = 100000;
+        }
+    }
+
+    struct coordinate coords[10000];
+    int num_cords = 0;
+
+    while (getline(&line_buf, &buffer_size, stdin) > 0) {    
+
+        sscanf(line_buf, "%d,%d\n", &coords[num_cords].x, &coords[num_cords].y);
+        num_cords++;
+
+    }
+
+    for (int i = 0; i < NUM_BYTES; i++) {
+
+        struct coordinate coord = coords[i];
+
+        values[coords[i].x][coords[i].y] = WALL;
+
+        //printf("%d, %dwa\n", coords[i].x, coords[i].y);
+        //values[coord.x][coord.y] = 10000;
+
+    }
+    
+    struct coordinate start;
+
+    start.x = 0;
+    start.y = 0;
+
+    printf("res: %d\n", dfs(start));
+}

src/c/2024/day19/part1.c

@@ -0,0 +1,90 @@
+#include <stdio.h>
+#include <string.h>
+
+char towels[1000][100];
+int towel_length[1000];
+
+char wanted[1000][100];
+
+int num_towels = 0;
+
+// returns index of first mismatch
+int first_mismatch(char* a, char* b) {
+
+    int i = 0;
+    while (a[i] == b[i] && a[i] && b[i]) {
+        i++;
+    }
+
+    return i;
+
+}
+
+
+// returns 1 if found, 0 if not
+int find_arrangement(char* wanted) {
+
+    if (wanted[0] == 0) {
+        return 1;
+    }
+
+    for (int i = 0; i < num_towels; i++) {
+
+        //printf("%s v %s: %d\n", wanted, towels[i], first_mismatch(wanted, towels[i]));
+
+        if (first_mismatch(wanted, towels[i]) == towel_length[i]) {
+         
+            if (find_arrangement(&wanted[towel_length[i]])) {
+                return 1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+
+
+int main() {
+
+    char *line_buf = NULL;
+    size_t buffer_size = 1000;
+
+    int amount = getline(&line_buf, &buffer_size, stdin);
+
+    int last_comma = 0;
+
+    for (int i = 0; i < amount; i++) {
+        if (line_buf[i] == ',') {
+            strncpy(towels[num_towels], &line_buf[last_comma], i - last_comma);
+            towels[num_towels][i - last_comma] = 0;
+            towel_length[num_towels] = i - last_comma;
+            //printf("%s\n", towels[num_towels]);
+            num_towels++;
+            last_comma = i + 2;
+        }
+    }
+
+    // parse empty line
+    getline(&line_buf, &buffer_size, stdin);
+
+    int num_wanted = 0;
+    int n;
+
+    while ((n = getline(&line_buf, &buffer_size, stdin)) > 0) {
+        strncpy(wanted[num_wanted], line_buf, n - 1);
+        
+        num_wanted++;
+        //printf("!%s\n", wanted[num_wanted - 1]);
+    }
+
+    int total = 0;
+    
+    for (int i = 0; i < num_wanted; i++) {
+        total += find_arrangement(wanted[i]);
+        //printf("%s, %d\n", wanted[i], find_arrangement(wanted[i]));
+    }
+
+    printf("res: %d", total);
+
+}

src/c/2024/day19/part2.c

@@ -0,0 +1,126 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define CACHE_SIZE 100000
+
+char towels[1000][100];
+int towel_length[1000];
+
+char wanted[1000][100];
+
+
+char cache_key[CACHE_SIZE][100];
+long cache_value[CACHE_SIZE];
+
+int cache_len = 0;
+
+
+int num_towels = 0;
+
+// returns index of first mismatch
+int first_mismatch(char* a, char* b) {
+
+    int i = 0;
+    while (a[i] == b[i] && a[i] && b[i]) {
+        i++;
+    }
+
+    return i;
+
+}
+
+
+// returns 1 if found, 0 if not
+long find_arrangement(char* wanted, int depth) {
+
+    if (wanted[0] == 0) {
+        return 1;
+    }
+
+    for (int i = 0; i < cache_len; i++) {
+        if (strcmp(cache_key[i], wanted) == 0) {
+            //printf("cache hit\n");
+            return cache_value[i];
+        }
+    }
+
+    long total = 0;
+
+    for (int i = 0; i < num_towels; i++) {
+
+        //if (depth == 0) {
+        //}
+
+        if (first_mismatch(wanted, towels[i]) == towel_length[i]) {
+
+            //if (depth <= 10) {
+                //printf("%d: %s v %s: %d.. %d\n", depth, wanted, towels[i], first_mismatch(wanted, towels[i]), total);
+            //}
+            total += find_arrangement(&wanted[towel_length[i]], depth + 1);
+
+        }
+    }
+
+    strcpy(cache_key[cache_len], wanted);
+    cache_value[cache_len] = total;
+    cache_len++;
+    return total;
+}
+
+
+
+int main() {
+
+    char *line_buf = NULL;
+    size_t buffer_size = 1000;
+
+    int amount = getline(&line_buf, &buffer_size, stdin);
+
+    int last_comma = 0;
+
+    for (int i = 0; i < amount; i++) {
+        if (line_buf[i] == ',') {
+            strncpy(towels[num_towels], &line_buf[last_comma], i - last_comma);
+            towels[num_towels][i - last_comma] = 0;
+            towel_length[num_towels] = i - last_comma;
+            //printf("%s, %d\n", towels[num_towels], towel_length[num_towels]);
+            num_towels++;
+            last_comma = i + 2;
+        }
+    }
+
+    strncpy(towels[num_towels], &line_buf[last_comma], amount - last_comma - 1);
+    towels[num_towels][amount - last_comma - 1] = 0;
+    towel_length[num_towels] = amount - last_comma - 1;
+    //printf("%s\n", towels[num_towels]);
+    num_towels++;
+
+    //exit(0);
+    
+
+
+    // parse empty line
+    getline(&line_buf, &buffer_size, stdin);
+
+    int num_wanted = 0;
+    int n;
+
+    while ((n = getline(&line_buf, &buffer_size, stdin)) > 0) {
+        strncpy(wanted[num_wanted], line_buf, n - 1);
+        
+        num_wanted++;
+        //printf("!%s\n", wanted[num_wanted - 1]);
+    }
+
+    long total = 0;
+    
+    for (int i = 0; i < num_wanted; i++) {
+        total += find_arrangement(wanted[i], 0);
+        printf("%s, %ld\n", wanted[i], find_arrangement(wanted[i], 0));
+        //printf("%s, %d\n", wanted[i], find_arrangement(wanted[i]));
+    }
+
+    printf("res: %ld", total);
+
+}

src/c/2024/day20/part1.c

@@ -0,0 +1,200 @@
+#include <stdio.h>
+#include <string.h>
+
+#define BOARD_SIZE 141
+
+#define IN_BOUND(x, y) (x < BOARD_SIZE && x >= 0 && y < BOARD_SIZE && y >= 0)
+#define MIN(a,b) (((a)<(b))?(a):(b))
+
+struct coordinate {
+
+    int x, y;
+
+};
+
+
+struct coordinate queue[10000];
+int queue_len;
+int queue_start;
+
+char map[BOARD_SIZE][BOARD_SIZE];
+int values[BOARD_SIZE][BOARD_SIZE];
+
+
+int queue_pop(struct coordinate *coord) {
+
+    if (queue_len == 0) {
+        return -1;
+    }
+
+    memcpy(coord, &queue[queue_start], sizeof(struct coordinate));
+
+    queue_start++;
+    queue_len--;
+
+    return 0;
+
+}
+
+
+void queue_push(struct coordinate *coord) {
+
+    
+    //printf("%d, %da\n", coord->x, coord->y);
+
+    memcpy(&queue[queue_start + queue_len], coord, sizeof(struct coordinate));
+    queue_len++;
+
+}
+
+
+void check_and_push(struct coordinate *coord, int depth) {
+
+    //printf("%d\n", depth);
+
+    if (!IN_BOUND(coord->x, coord->y) || map[coord->x][coord->y] == '#') {
+        return;
+    }
+
+    if (values[coord->x][coord->y] == 100000) {
+        //printf("%d\n", depth);
+        values[coord->x][coord->y] = depth + 1;
+        queue_push(coord);
+
+    }
+
+
+}
+
+int dfs(struct coordinate coord) {
+
+    queue_push(&coord);
+    values[coord.x][coord.y] = 0;
+
+    while (!queue_pop(&coord)) {
+
+        //printf("%d, %d!", coord.x, coord.y);
+
+        int value = values[coord.x][coord.y];
+
+        //printf("%d, %d: %d\n", coord.x, coord.y, values[coord.x][coord.y]);
+
+        coord.x++;
+        check_and_push(&coord, value);
+        coord.x -= 2;
+        check_and_push(&coord, value);
+        coord.x++;
+
+        coord.y++;
+        check_and_push(&coord, value);
+        coord.y -= 2;
+        check_and_push(&coord, value);
+        coord.y++;
+
+
+    }
+
+    return 0;
+}
+
+int cheats = 0;
+
+int test_cheat(int x, int y, int value) {
+    int v;
+    if (IN_BOUND(x, y) && (map[x][y] == '.' || map[x][y] == 'E') && (v = values[x][y] - value) > 2) {
+        v -= 2;
+        printf("cheat: %d\n", v, x, y);
+
+        if (v >= 100) {
+            cheats++;
+        }
+
+        return v;
+    }   
+    return 0;
+}
+
+int test_next(int x, int y, int value) {
+    //printf("%d, %d\n", value, values[x][y]);
+    return (IN_BOUND(x, y) && map[x][y] == '.' && values[x][y] - value == 1);
+}
+
+
+int find_cheat(int x, int y) {
+
+    //printf("%d, %d ", x, y);
+    //printf("%c\n", map[x][y]);
+
+    if (!IN_BOUND(x, y)) {
+        return 0;
+    }
+
+
+    int value = values[x][y];
+    int v;
+
+    test_cheat(x, y + 2, value);
+    test_cheat(x, y - 2, value);
+    test_cheat(x + 2, y, value);
+    test_cheat(x - 2, y, value);
+
+    if (test_next(x + 1, y, value)) {
+        return find_cheat(x + 1, y);
+    }
+    if (test_next(x - 1, y, value)) {
+        return find_cheat(x - 1, y);
+    }
+    if (test_next(x, y + 1, value)) {
+        return find_cheat(x, y + 1);
+    }
+    if (test_next(x, y - 1, value)) {
+        return find_cheat(x, y - 1);
+    }
+
+    return 0;
+
+}
+
+
+
+int main() {
+
+    char *line_buf = NULL;
+    size_t buffer_size = 100;
+
+    for (int i = 0; i < BOARD_SIZE; i++) {
+        for (int j = 0; j < BOARD_SIZE; j++) {
+            map[i][j] = '.';
+            values[i][j] = 100000;
+        }
+    }
+
+    struct coordinate coords[10000];
+    int num_cords = 0;
+
+    
+    struct coordinate start, end;
+
+    int y = 0;
+    while (getline(&line_buf, &buffer_size, stdin) > 0) { 
+        for (int x = 0; x < BOARD_SIZE; x++) {
+            map[x][y] = line_buf[x];
+
+            if (line_buf[x] == 'S') {
+                start.x = x;
+                start.y = y;
+            }
+
+            if (line_buf[x] == 'E') {
+                end.x = x;
+                end.y = y;
+            }
+        }
+        y++;
+    }
+
+    dfs(start);
+    find_cheat(start.x, start.y);
+
+    printf("res: %d", cheats);
+}

src/c/2024/day20/part2.c

@@ -0,0 +1,224 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define BOARD_SIZE 141
+
+#define CHEAT_LENGTH 20
+
+#define IN_BOUND(x, y) (x < BOARD_SIZE && x >= 0 && y < BOARD_SIZE && y >= 0)
+#define MIN(a,b) (((a)<(b))?(a):(b))
+
+struct coordinate {
+
+    int x, y;
+
+};
+
+
+struct coordinate queue[10000];
+int queue_len;
+int queue_start;
+
+char map[BOARD_SIZE][BOARD_SIZE];
+int values[BOARD_SIZE][BOARD_SIZE];
+
+struct coordinate cheat_deltas[10000];
+int num_cheat_deltas;
+
+
+int queue_pop(struct coordinate *coord) {
+
+    if (queue_len == 0) {
+        return -1;
+    }
+
+    memcpy(coord, &queue[queue_start], sizeof(struct coordinate));
+
+    queue_start++;
+    queue_len--;
+
+    return 0;
+
+}
+
+
+void queue_push(struct coordinate *coord) {
+
+    
+    //printf("%d, %da\n", coord->x, coord->y);
+
+    memcpy(&queue[queue_start + queue_len], coord, sizeof(struct coordinate));
+    queue_len++;
+
+}
+
+
+void check_and_push(struct coordinate *coord, int depth) {
+
+    //printf("%d\n", depth);
+
+    if (!IN_BOUND(coord->x, coord->y) || map[coord->x][coord->y] == '#') {
+        return;
+    }
+
+    if (values[coord->x][coord->y] == 100000) {
+        //printf("%d\n", depth);
+        values[coord->x][coord->y] = depth + 1;
+        queue_push(coord);
+
+    }
+
+
+}
+
+int dfs(struct coordinate coord) {
+
+    queue_push(&coord);
+    values[coord.x][coord.y] = 0;
+
+    while (!queue_pop(&coord)) {
+
+        //printf("%d, %d!", coord.x, coord.y);
+
+        int value = values[coord.x][coord.y];
+
+        //printf("%d, %d: %d\n", coord.x, coord.y, values[coord.x][coord.y]);
+
+        coord.x++;
+        check_and_push(&coord, value);
+        coord.x -= 2;
+        check_and_push(&coord, value);
+        coord.x++;
+
+        coord.y++;
+        check_and_push(&coord, value);
+        coord.y -= 2;
+        check_and_push(&coord, value);
+        coord.y++;
+
+
+    }
+
+    return 0;
+}
+
+int cheats = 0;
+
+int test_cheat(int x, int y, int value, int dist) {
+    int v;
+    if (IN_BOUND(x, y) && (map[x][y] == '.' || map[x][y] == 'E') && (v = values[x][y] - value) > dist) {
+        v -= dist;
+        //printf("cheat: %d\n", v, x, y);
+
+        if (v >= 100) {
+            cheats++;
+        }
+
+        return v;
+    }   
+    return 0;
+}
+
+int test_next(int x, int y, int value) {
+    //printf("%d, %d\n", value, values[x][y]);
+    return (IN_BOUND(x, y) && map[x][y] == '.' && values[x][y] - value == 1);
+}
+
+
+int find_cheat(int x, int y) {
+
+    printf("%d, %d ", x, y);
+    printf("%c\n", map[x][y]);
+
+    if (!IN_BOUND(x, y)) {
+        return 0;
+    }
+
+
+    int value = values[x][y];
+    int v;
+
+    for (int i = 0; i < num_cheat_deltas; i++) {
+        //printf("%d, %d\n", x + cheat_deltas[i].x, y + cheat_deltas[i].y);
+        test_cheat(x + cheat_deltas[i].x, y + cheat_deltas[i].y, value, abs(cheat_deltas[i].x) + abs(cheat_deltas[i].y));
+    }
+
+    if (test_next(x + 1, y, value)) {
+        return find_cheat(x + 1, y);
+    }
+    if (test_next(x - 1, y, value)) {
+        return find_cheat(x - 1, y);
+    }
+    if (test_next(x, y + 1, value)) {
+        return find_cheat(x, y + 1);
+    }
+    if (test_next(x, y - 1, value)) {
+        return find_cheat(x, y - 1);
+    }
+
+    return 0;
+
+}
+
+
+
+int main() {
+
+    // calc cheats
+    
+    for (int x = -CHEAT_LENGTH; x <= CHEAT_LENGTH; x++) {
+        for (int y = -CHEAT_LENGTH; y <= CHEAT_LENGTH; y++) {
+
+            if (abs(x) + abs(y) <= CHEAT_LENGTH) {
+                //printf("%d, %d\n", x, y);
+
+                cheat_deltas[num_cheat_deltas].x = x;
+                cheat_deltas[num_cheat_deltas].y = y;
+                num_cheat_deltas++;
+                
+            }
+        }
+    }
+
+    //exit(0);
+
+    char *line_buf = NULL;
+    size_t buffer_size = 100;
+
+    for (int i = 0; i < BOARD_SIZE; i++) {
+        for (int j = 0; j < BOARD_SIZE; j++) {
+            map[i][j] = '.';
+            values[i][j] = 100000;
+        }
+    }
+
+    struct coordinate coords[10000];
+    int num_cords = 0;
+
+    
+    struct coordinate start, end;
+
+    int y = 0;
+    while (getline(&line_buf, &buffer_size, stdin) > 0) {
+        printf(line_buf);
+        for (int x = 0; x < BOARD_SIZE; x++) {
+            map[x][y] = line_buf[x];
+
+            if (line_buf[x] == 'S') {
+                start.x = x;
+                start.y = y;
+            }
+
+            if (line_buf[x] == 'E') {
+                end.x = x;
+                end.y = y;
+            }
+        }
+        y++;
+    }
+
+    dfs(start);
+    find_cheat(start.x, start.y);
+    printf("res: %d", cheats);
+}

src/c/2024/day24/part2.c

@@ -21,6 +21,10 @@ int number_from_id(int id) {
 
 }
 
+int get_letter(int id) {
+    return id / 65536;
+}
+
 int operator_to_id(char* str){
 
     if (strcmp(str, "AND") == 0) { 
@@ -148,8 +152,11 @@ int main() {
         num_rules++;
     }
 
-    int found_zs[max_z];
     max_z++;
+    int xy_ands[max_z];
+    int xy_xors[max_z];
+
+
     int rule_applied[num_rules];
 
     for (int i = 0; i < num_rules; i++) {
@@ -160,76 +167,32 @@ int main() {
 
     for (int i = 0; i < max_z; i++) {
 
-        found_zs[i] = 0;
+        xy_ands[i] = 0;
+        xy_xors[i] = 0;
 
     }
 
     printf("Read %d values and %d rules, trying to find %d zs\n", num_values, num_rules, max_z);
 
-    for (;;) {
+    for (int i = 0; i < num_rules; i++) {
 
-        for (int i = 0; i < num_rules; i++) {  
+        if (get_letter(rules[i].op1) == 'x' && get_letter(rules[i].op2) == 'y' ||
+            get_letter(rules[i].op1) == 'y' && get_letter(rules[i].op2) == 'x') {
 
-            int v1, v2;
-
-            if (rule_applied[i]) {
-                continue;
+            if (rules[i].operator == 3) {
+                xy_xors[number_from_id(rules[i].op1)] = rules[i].result;
+            } else if (rules[i].operator == 1) {
+                xy_ands[number_from_id(rules[i].op1)] = rules[i].result;
             }
 
-            if ((v1 = get_value(rules[i].op1)) >= 0 && (v2 = get_value(rules[i].op2)) >= 0) {
-
-                int res = apply_operator(v1, rules[i].operator, v2);
-
-                //printf("%d: %d\n", rules[i].result, res);
-                
-                add_value(rules[i].result, res);
-
-                if (rules[i].result / 65536 == 'z') {
-
-                    found_zs[number_from_id(rules[i].result)] = 1;
-                    printf("Found z%d\n", number_from_id(rules[i].result)); 
-                    //printf("%x", rules[i].result);
-
-                }
-
-                rule_applied[i] = 1;
-
-            }
-
-            //printf("%d, %d\n", v1, v2);
-
+            printf("%d: %d %d\n", rules[i].operator, number_from_id(rules[i].op1), number_from_id(rules[i].op2));
         }
 
-        int finished = 1;
-        for (int i = 0; i < max_z; i++) {
-
-            if (found_zs[i] == 0) {
-
-                finished = 0;
-                break;
-
-            }
+    
 
+        if (rules[i].result / 65536 == 'z') {
+            //printf("%d", rules[i].operator);
         }
 
-        if (finished) {
-
-            break;
-
-        }
-        
     }
-
-    long out = 0;
-    for (int i = max_z - 1; i >= 0; i--) {
-
-        out *= 2;
-        int n = get_value(zvalue_to_id(i));
-        printf("%d", n);
-        out += n;
-
-        //printf("%x\n", zvalue_to_id(i));
-    }
-
-    printf("\nres: %ld\n", out);
 }

src/plasl/2025/day2/part1.psl

@@ -0,0 +1,189 @@
+
+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[20] 20+ 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-`}
+}
+
+u64 pow(u64, u64) {
+    `sudsl` 
+
+    u64(1)`si`
+    while (`lilu` < ) {
+        `ll*`
+        `li`u64(1)`+si`
+    }
+    
+}
+
+
+u64 range(u64, u64, i32) {
+    set len set end set start
+
+    println("==")
+    get start printnum64 ' ' putc get end printnum64 i8(10) putc
+
+    if (get len 1 & 1 ==) {
+        u64(0) return
+    }
+
+    pow(u64(10), get len 2/ as u64) u64(1)+ set divisor
+
+    get start get divisor + u64(1) - get divisor / set first
+    get end get divisor / set second 
+
+    i8(10) putc
+    get divisor printnum64 i8(10) putc
+    get first printnum64 ' ' putc get second printnum64 i8(10) putc
+
+    u64(1) get second + get first - get second get first +* u64(2) / get divisor *
+
+    dup printnum64 i8(10) putc
+}
+
+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+ ',' store
+
+    u64(0) set out
+    0 set i 
+
+    while (get i get size <) {
+        println("--------------")
+        0 set startlen 0 set endlen
+        atol(get buffer get i+) set start
+
+        while (get buffer get i+ load '-' !=) {
+            `li1+si`
+            get startlen 1+ set startlen
+        }
+        `li1+si`
+
+        atol(get buffer get i+) set end
+
+        while (get buffer get i+ load ',' !=) {
+            `li1+si`
+            get endlen 1+ set endlen
+        }
+        `li1+si`
+
+        get startlen printnum ' ' putc get start printnum64 i8(10) putc
+        get endlen printnum ' ' putc get end printnum64 i8(10) putc
+
+        if (get endlen get startlen !=) {
+            range(get start, pow(u64(10), get startlen as u64) u64(1)-, get startlen)
+            range(pow(u64(10), get startlen as u64), get end, get endlen)
+            +
+        } else {
+            range(get start, get end, get startlen) 
+        }
+        get out + set out
+
+        i8(10) putc
+    }
+
+
+    println("answer:")
+    get out printnum64 i8(10) putc
+    exit(0)
+}
+
+void main() {
+    _start
+}