struct Test {
   a: 64,
   b: 64,
   c: 64,
}

struct Test2 {
   a: 64,
   b: Test,
   c: Test,
}

fn start() {
   println("Helld!");
   print_hex(rem(10, 7));
   println("");
   println("Hello World!!!!!");
   thinger();
   let x = 3;
   if not(not(lt(x, 5))) {
      println("tada!");
   };
   println("before:");
   x = 0;
   loop {
      if not(lt(x, 10)) {
         break;
      };
      println("RAAAAA");
      x = add(x, 1);
   };
   println("after");
   let infer_me: slice<_> = "hello";
   print(tester());
   let test: Test = Test {
      a: 10,
      b: 4,
      c: 0,
   };
   structer(test);
   arger("a", "b", "c");
   let z = sub(test.a, 10);
   print_hex(add(mul(sub(add(10, test.b), 1), 3), z));
   print("test: 0x");
   print_hex(31);
   println("");
   generic();
   exit(0);
}

fn structer(test: Test) {
   print("test {\n   a: ");
   print_dec(test.a);
   print("\n   b: ");
   print_dec(test.b);
   print("\n   c: ");
   print_dec(test.c);
   println("\n}");
   print("update c: ");
   test.c = add(test.a, test.b);
   print_dec(test.c);
   println("");

   let test2: Test2 = Test2 {
      a: 3,
      b: test,
      c: test,
   };
   test2.c.c = 20;
   print("test2.b.c: ");
   print_dec(test2.b.c);
   println("");
   print("test2.c.c: ");
   print_dec(test2.c.c);
   println("");
}

struct GTest<T, U, V> {
   a: T,
   b: U,
   c: V,
}

fn generic() {
   let gt = GTest {
      a: 39,
      b: "hello",
      c: 40,
   };
   print("generic: ");
   print_dec(gt.a);
   print(", ");
   print(gt.b);
   print_dec(gt.c);
   println("");
}

fn thinger() {
   print("estamos jugando\n");
}

fn unused() {
   print("el unused\n");
}

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

fn arger(a: slice<8>, b: slice<8>, c: slice<8>) {
   print(a);
   print(b);
   println(c);
}

fn exit(status: 64) {
   asm (a0 = status) {
      li a7, 93
      ecall
   };
}

fn tester() -> slice<8> {
   "hola\n"
}