more import preparation

data/util.lang

@@ -0,0 +1,146 @@
+fn exit(status: 64) {
+   asm (a0 = status) {
+      li a7, 93
+      ecall
+   };
+}
+
+fn println(msg: slice<8>) {
+   print(msg);
+   print("\n");
+}
+
+fn print(msg: slice<8>) {
+   asm (a1 = &msg) {
+      ld a2, 8, a1
+      ld a1, 0, a1
+      li a0, 1
+      li a7, 64
+      ecall
+   }
+}
+
+fn print_hex(x: 64) {
+   let i = 64;
+   loop {
+      i = sub(i, 4);
+      let c = and(shr(x, i), 15);
+      if gt(c, 9) {
+         c = add(c, 7);
+      };
+      c = add(c, 48);
+      asm (a1 = &c) {
+         li a2, 1
+         li a0, 1
+         li a7, 64
+         ecall
+      };
+      if lt(i, 1) {
+         break;
+      };
+   }
+}
+
+fn print_dec(x: 64) {
+   let i = 1;
+   loop {
+      if gt(i, x) {
+         if lt(i, 2) {
+            print("0");
+            return;
+         };
+         break;
+      };
+      i = mul(i, 10);
+   };
+   let found = 0;
+   loop {
+      i = div(i, 10);
+      let c = rem(div(x, i), 10);
+      if and(lt(c, 1), not(found)) {
+         continue;
+      };
+      found = 1;
+      if gt(c, 9) {
+         c = add(c, 7);
+      };
+      c = add(c, 48);
+      asm (a1 = &c) {
+         li a2, 1
+         li a0, 1
+         li a7, 64
+         ecall
+      };
+      if lt(i, 2) {
+         break;
+      };
+   };
+   if not(found) {
+      print("0");
+   }
+}
+
+fn add(a: 64, b: 64) -> 64 {
+   asm (t0 = a, t1 = b, out = t0) {
+      add t0, t0, t1
+   }
+}
+
+fn mul(a: 64, b: 64) -> 64 {
+   asm (t0 = a, t1 = b, out = t0) {
+      mul t0, t0, t1
+   }
+}
+
+fn div(a: 64, b: 64) -> 64 {
+   asm (t0 = a, t1 = b, out = t0) {
+      div t0, t0, t1
+   }
+}
+
+fn sub(a: 64, b: 64) -> 64 {
+   asm (t0 = a, t1 = b, out = t0) {
+      sub t0, t0, t1
+   }
+}
+
+fn rem(a: 64, b: 64) -> 64 {
+   asm (t0 = a, t1 = b, out = t0) {
+      rem t0, t0, t1
+   }
+}
+
+fn shr(a: 64, b: 64) -> 64 {
+   asm (t0 = a, t1 = b, out = t0) {
+      srl t0, t0, t1
+   }
+}
+
+fn shl(a: 64, b: 64) -> 64 {
+   asm (t0 = a, t1 = b, out = t0) {
+      sll t0, t0, t1
+   }
+}
+
+fn lt(a: 64, b: 64) -> 64 {
+   asm (t0 = a, t1 = b, out = t0) {
+      slt t0, t0, t1
+   }
+}
+
+fn gt(a: 64, b: 64) -> 64 {
+    lt(b, a)
+}
+
+fn and(a: 64, b: 64) -> 64 {
+   asm (t0 = a, t1 = b, out = t0) {
+      and t0, t0, t1
+   }
+}
+
+fn not(a: 64) -> 64 {
+   asm (t0 = a, out = t0) {
+      xori t0, t0, 1
+   }
+}
+