add more stuff to lib

fix use after free

7 files changed, 922 insertions, 817 deletions

diff --git a/code/basic.felan b/code/basic.felan
index d8121c2..27d1796 100644
--- a/code/basic.felan
+++ b/code/basic.felan
@@ -1,792 +1,3 @@
-__plus__ :: (value:u8) -> u8 {
-  return value;
-};
-
-__plus__ :: (value:i8) -> i8 {
-  return value;
-};
-
-__plus__ :: (value:u16) -> u16 {
-  return value;
-};
-
-__plus__ :: (value:i16) -> i16 {
-  return value;
-};
-
-__plus__ :: (value:u32) -> u32 {
-  return value;
-};
-
-__plus__ :: (value:i32) -> i32 {
-  return value;
-};
-
-__plus__ :: (value:u64) -> u64 {
-  return value;
-};
-
-__plus__ :: (value:i64) -> i64 {
-  return value;
-};
-
-__minus__ :: (value:i8) -> i8 {
-  return @neg(value);
-};
-
-__minus__ :: (value:i16) -> i16 {
-  return @neg(value);
-};
-
-__minus__ :: (value:i32) -> i32 {
-  return @neg(value);
-};
-
-__minus__ :: (value:i64) -> i64 {
-  return @neg(value);
-};
-
-__sum__ :: (left:u8,right:u8) -> u8 {
-  return @add(left,right);
-};
-
-__sum__ :: (left:i8,right:i8) -> i8 {
-  return @add(left,right);
-};
-
-__sum__ :: (left:u16,right:u16) -> u16 {
-  return @add(left,right);
-};
-
-__sum__ :: (left:i16,right:i16) -> i16 {
-  return @add(left,right);
-};
-
-__sum__ :: (left:u32,right:u32) -> u32 {
-  return @add(left,right);
-};
-
-__sum__ :: (left:i32,right:i32) -> i32 {
-  return @add(left,right);
-};
-
-__sum__ :: (left:u64,right:u64) -> u64 {
-  return @add(left,right);
-};
-
-__sum__ :: (left:i64,right:i64) -> i64 {
-  return @add(left,right);
-};
-
-__sum__ :: (left:f16,right:f16) -> f16 {
-  return @add(left,right);
-};
-
-__sum__ :: (left:f32,right:f32) -> f32 {
-  return @add(left,right);
-};
-
-__sum__ :: (left:f64,right:f64) -> f64 {
-  return @add(left,right);
-};
-
-__sum__ :: (left:f128,right:f128) -> f128 {
-  return @add(left,right);
-};
-
-__sub__ :: (left:u8,right:u8) -> u8 {
-  return @sub(left,right);
-};
-
-__sub__ :: (left:i8,right:i8) -> i8 {
-  return @sub(left,right);
-};
-
-__sub__ :: (left:u16,right:u16) -> u16 {
-  return @sub(left,right);
-};
-
-__sub__ :: (left:i16,right:i16) -> i16 {
-  return @sub(left,right);
-};
-
-__sub__ :: (left:u32,right:u32) -> u32 {
-  return @sub(left,right);
-};
-
-__sub__ :: (left:i32,right:i32) -> i32 {
-  return @sub(left,right);
-};
-
-__sub__ :: (left:u64,right:u64) -> u64 {
-  return @sub(left,right);
-};
-
-__sub__ :: (left:i64,right:i64) -> i64 {
-  return @sub(left,right);
-};
-
-__sub__ :: (left:f16,right:f16) -> f16 {
-  return @sub(left,right);
-};
-
-__sub__ :: (left:f32,right:f32) -> f32 {
-  return @sub(left,right);
-};
-
-__sub__ :: (left:f64,right:f64) -> f64 {
-  return @sub(left,right);
-};
-
-__sub__ :: (left:f128,right:f128) -> f128 {
-  return @sub(left,right);
-};
-
-__mul__ :: (left:u8,right:u8) -> u8 {
-  return @mul(left,right);
-};
-
-__mul__ :: (left:i8,right:i8) -> i8 {
-  return @mul(left,right);
-};
-
-__mul__ :: (left:u16,right:u16) -> u16 {
-  return @mul(left,right);
-};
-
-__mul__ :: (left:i16,right:i16) -> i16 {
-  return @mul(left,right);
-};
-
-__mul__ :: (left:u32,right:u32) -> u32 {
-  return @mul(left,right);
-};
-
-__mul__ :: (left:i32,right:i32) -> i32 {
-  return @mul(left,right);
-};
-
-__mul__ :: (left:u64,right:u64) -> u64 {
-  return @mul(left,right);
-};
-
-__mul__ :: (left:i64,right:i64) -> i64 {
-  return @mul(left,right);
-};
-
-__mul__ :: (left:f16,right:f16) -> f16 {
-  return @mul(left,right);
-};
-
-__mul__ :: (left:f32,right:f32) -> f32 {
-  return @mul(left,right);
-};
-
-__mul__ :: (left:f64,right:f64) -> f64 {
-  return @mul(left,right);
-};
-
-__mul__ :: (left:f128,right:f128) -> f128 {
-  return @mul(left,right);
-};
-
-__div__ :: (left:u8,right:u8) -> u8 {
-  return @div(left,right);
-};
-
-__div__ :: (left:i8,right:i8) -> i8 {
-  return @div(left,right);
-};
-
-__div__ :: (left:u16,right:u16) -> u16 {
-  return @div(left,right);
-};
-
-__div__ :: (left:i16,right:i16) -> i16 {
-  return @div(left,right);
-};
-
-__div__ :: (left:u32,right:u32) -> u32 {
-  return @div(left,right);
-};
-
-__div__ :: (left:i32,right:i32) -> i32 {
-  return @div(left,right);
-};
-
-__div__ :: (left:u64,right:u64) -> u64 {
-  return @div(left,right);
-};
-
-__div__ :: (left:i64,right:i64) -> i64 {
-  return @div(left,right);
-};
-
-__div__ :: (left:f16,right:f16) -> f16 {
-  return @div(left,right);
-};
-
-__div__ :: (left:f32,right:f32) -> f32 {
-  return @div(left,right);
-};
-
-__div__ :: (left:f64,right:f64) -> f64 {
-  return @div(left,right);
-};
-
-__div__ :: (left:f128,right:f128) -> f128 {
-  return @div(left,right);
-};
-
-__mod__ :: (left:u8,right:u8) -> u8 {
-  return @mod(left,right);
-};
-
-__mod__ :: (left:i8,right:i8) -> i8 {
-  return @mod(left,right);
-};
-
-__mod__ :: (left:u16,right:u16) -> u16 {
-  return @mod(left,right);
-};
-
-__mod__ :: (left:i16,right:i16) -> i16 {
-  return @mod(left,right);
-};
-
-__mod__ :: (left:u32,right:u32) -> u32 {
-  return @mod(left,right);
-};
-
-__mod__ :: (left:i32,right:i32) -> i32 {
-  return @mod(left,right);
-};
-
-__mod__ :: (left:u64,right:u64) -> u64 {
-  return @mod(left,right);
-};
-
-__mod__ :: (left:i64,right:i64) -> i64 {
-  return @mod(left,right);
-};
-
-__greater__ :: (left:u8,right:u8) -> bool {
-  return @greater(left,right);
-};
-
-__greater__ :: (left:i8,right:i8) -> bool {
-  return @greater(left,right);
-};
-
-__greater__ :: (left:u16,right:u16) -> bool {
-  return @greater(left,right);
-};
-
-__greater__ :: (left:i16,right:i16) -> bool {
-  return @greater(left,right);
-};
-
-__greater__ :: (left:u32,right:u32) -> bool {
-  return @greater(left,right);
-};
-
-__greater__ :: (left:i32,right:i32) -> bool {
-  return @greater(left,right);
-};
-
-__greater__ :: (left:u64,right:u64) -> bool {
-  return @greater(left,right);
-};
-
-__greater__ :: (left:i64,right:i64) -> bool {
-  return @greater(left,right);
-};
-
-__greater__ :: (left:f16,right:f16) -> bool {
-  return @greater(left,right);
-};
-
-__greater__ :: (left:f32,right:f32) -> bool {
-  return @greater(left,right);
-};
-
-__greater__ :: (left:f64,right:f64) -> bool {
-  return @greater(left,right);
-};
-
-__greater__ :: (left:f128,right:f128) -> bool {
-  return @greater(left,right);
-};
-
-__smaller__ :: (left:u8,right:u8) -> bool {
-  return @smaller(left,right);
-};
-
-__smaller__ :: (left:i8,right:i8) -> bool {
-  return @smaller(left,right);
-};
-
-__smaller__ :: (left:u16,right:u16) -> bool {
-  return @smaller(left,right);
-};
-
-__smaller__ :: (left:i16,right:i16) -> bool {
-  return @smaller(left,right);
-};
-
-__smaller__ :: (left:u32,right:u32) -> bool {
-  return @smaller(left,right);
-};
-
-__smaller__ :: (left:i32,right:i32) -> bool {
-  return @smaller(left,right);
-};
-
-__smaller__ :: (left:u64,right:u64) -> bool {
-  return @smaller(left,right);
-};
-
-__smaller__ :: (left:i64,right:i64) -> bool {
-  return @smaller(left,right);
-};
-
-__smaller__ :: (left:f16,right:f16) -> bool {
-  return @smaller(left,right);
-};
-
-__smaller__ :: (left:f32,right:f32) -> bool {
-  return @smaller(left,right);
-};
-
-__smaller__ :: (left:f64,right:f64) -> bool {
-  return @smaller(left,right);
-};
-
-__smaller__ :: (left:f128,right:f128) -> bool {
-  return @smaller(left,right);
-};
-
-__greater_or_equal__ :: (left:u8,right:u8) -> bool {
-  return @greater_or_equal(left,right);
-};
-
-__greater_or_equal__ :: (left:i8,right:i8) -> bool {
-  return @greater_or_equal(left,right);
-};
-
-__greater_or_equal__ :: (left:u16,right:u16) -> bool {
-  return @greater_or_equal(left,right);
-};
-
-__greater_or_equal__ :: (left:i16,right:i16) -> bool {
-  return @greater_or_equal(left,right);
-};
-
-__greater_or_equal__ :: (left:u32,right:u32) -> bool {
-  return @greater_or_equal(left,right);
-};
-
-__greater_or_equal__ :: (left:i32,right:i32) -> bool {
-  return @greater_or_equal(left,right);
-};
-
-__greater_or_equal__ :: (left:u64,right:u64) -> bool {
-  return @greater_or_equal(left,right);
-};
-
-__greater_or_equal__ :: (left:i64,right:i64) -> bool {
-  return @greater_or_equal(left,right);
-};
-
-__greater_or_equal__ :: (left:f16,right:f16) -> bool {
-  return @greater_or_equal(left,right);
-};
-
-__greater_or_equal__ :: (left:f32,right:f32) -> bool {
-  return @greater_or_equal(left,right);
-};
-
-__greater_or_equal__ :: (left:f64,right:f64) -> bool {
-  return @greater_or_equal(left,right);
-};
-
-__greater_or_equal__ :: (left:f128,right:f128) -> bool {
-  return @greater_or_equal(left,right);
-};
-
-__smaller_or_equal__ :: (left:u8,right:u8) -> bool {
-  return @smaller_or_equal(left,right);
-};
-
-__smaller_or_equal__ :: (left:i8,right:i8) -> bool {
-  return @smaller_or_equal(left,right);
-};
-
-__smaller_or_equal__ :: (left:u16,right:u16) -> bool {
-  return @smaller_or_equal(left,right);
-};
-
-__smaller_or_equal__ :: (left:i16,right:i16) -> bool {
-  return @smaller_or_equal(left,right);
-};
-
-__smaller_or_equal__ :: (left:u32,right:u32) -> bool {
-  return @smaller_or_equal(left,right);
-};
-
-__smaller_or_equal__ :: (left:i32,right:i32) -> bool {
-  return @smaller_or_equal(left,right);
-};
-
-__smaller_or_equal__ :: (left:u64,right:u64) -> bool {
-  return @smaller_or_equal(left,right);
-};
-
-__smaller_or_equal__ :: (left:i64,right:i64) -> bool {
-  return @smaller_or_equal(left,right);
-};
-
-__smaller_or_equal__ :: (left:f16,right:f16) -> bool {
-  return @smaller_or_equal(left,right);
-};
-
-__smaller_or_equal__ :: (left:f32,right:f32) -> bool {
-  return @smaller_or_equal(left,right);
-};
-
-__smaller_or_equal__ :: (left:f64,right:f64) -> bool {
-  return @smaller_or_equal(left,right);
-};
-
-__smaller_or_equal__ :: (left:f128,right:f128) -> bool {
-  return @smaller_or_equal(left,right);
-};
-
-__equal__ :: (left:u8,right:u8) -> bool {
-  return @equal(left,right);
-};
-
-__equal__ :: (left:i8,right:i8) -> bool {
-  return @equal(left,right);
-};
-
-__equal__ :: (left:u16,right:u16) -> bool {
-  return @equal(left,right);
-};
-
-__equal__ :: (left:i16,right:i16) -> bool {
-  return @equal(left,right);
-};
-
-__equal__ :: (left:u32,right:u32) -> bool {
-  return @equal(left,right);
-};
-
-__equal__ :: (left:i32,right:i32) -> bool {
-  return @equal(left,right);
-};
-
-__equal__ :: (left:u64,right:u64) -> bool {
-  return @equal(left,right);
-};
-
-__equal__ :: (left:i64,right:i64) -> bool {
-  return @equal(left,right);
-};
-
-__equal__ :: (left:f16,right:f16) -> bool {
-  return @equal(left,right);
-};
-
-__equal__ :: (left:f32,right:f32) -> bool {
-  return @equal(left,right);
-};
-
-__equal__ :: (left:f64,right:f64) -> bool {
-  return @equal(left,right);
-};
-
-__equal__ :: (left:f128,right:f128) -> bool {
-  return @equal(left,right);
-};
-
-__equal__ :: (left:bool,right:bool) -> bool {
-  return @equal(left,right);
-};
-
-__equal__ :: (left:type,right:type) -> bool {
-  return @equal(left,right);
-};
-
-__not_equal__ :: (left:u8,right:u8) -> bool {
-  return @not_equal(left,right);
-};
-
-__not_equal__ :: (left:i8,right:i8) -> bool {
-  return @not_equal(left,right);
-};
-
-__not_equal__ :: (left:u16,right:u16) -> bool {
-  return @not_equal(left,right);
-};
-
-__not_equal__ :: (left:i16,right:i16) -> bool {
-  return @not_equal(left,right);
-};
-
-__not_equal__ :: (left:u32,right:u32) -> bool {
-  return @not_equal(left,right);
-};
-
-__not_equal__ :: (left:i32,right:i32) -> bool {
-  return @not_equal(left,right);
-};
-
-__not_equal__ :: (left:u64,right:u64) -> bool {
-  return @not_equal(left,right);
-};
-
-__not_equal__ :: (left:i64,right:i64) -> bool {
-  return @not_equal(left,right);
-};
-
-__not_equal__ :: (left:f16,right:f16) -> bool {
-  return @not_equal(left,right);
-};
-
-__not_equal__ :: (left:f32,right:f32) -> bool {
-  return @not_equal(left,right);
-};
-
-__not_equal__ :: (left:f64,right:f64) -> bool {
-  return @not_equal(left,right);
-};
-
-__not_equal__ :: (left:f128,right:f128) -> bool {
-  return @not_equal(left,right);
-};
-
-__not_equal__ :: (left:bool,right:bool) -> bool {
-  return @not_equal(left,right);
-};
-
-__not_equal__ :: (left:type,right:type) -> bool {
-  return @not_equal(left,right);
-};
-
-__logical_not__ :: (value:bool) -> bool {
-  return value == false;
-};
-
-__logical_and__ :: (left:bool,lazy right:bool) -> bool {
-  if left == false {
-    return false;
-  } else if right == false {
-    return false;
-  } else {
-    return true;
-  }
-};
-
-__logical_or__ :: (left:bool,lazy right:bool) -> bool {
-  if left == true {
-    return true;
-  } else if right == true {
-    return true;
-  } else {
-    return false;
-  }
-};
-
-__bitwise_not__ :: (value:u8) -> u8 {
-  return @bitwise_not(value);
-};
-
-__bitwise_not__ :: (value:i8) -> i8 {
-  return @bitwise_not(value);
-};
-
-__bitwise_not__ :: (value:u16) -> u16 {
-  return @bitwise_not(value);
-};
-
-__bitwise_not__ :: (value:i16) -> i16 {
-  return @bitwise_not(value);
-};
-
-__bitwise_not__ :: (value:u32) -> u32 {
-  return @bitwise_not(value);
-};
-
-__bitwise_not__ :: (value:i32) -> i32 {
-  return @bitwise_not(value);
-};
-
-__bitwise_not__ :: (value:u64) -> u64 {
-  return @bitwise_not(value);
-};
-
-__bitwise_not__ :: (value:i64) -> i64 {
-  return @bitwise_not(value);
-};
-
-__bitwise_and__ :: (left:u8,right:u8) -> u8 {
-  return @bitwise_and(left,right);
-};
-
-__bitwise_and__ :: (left:i8,right:i8) -> i8 {
-  return @bitwise_and(left,right);
-};
-
-__bitwise_and__ :: (left:u16,right:u16) -> u16 {
-  return @bitwise_and(left,right);
-};
-
-__bitwise_and__ :: (left:i16,right:i16) -> i16 {
-  return @bitwise_and(left,right);
-};
-
-__bitwise_and__ :: (left:u32,right:u32) -> u32 {
-  return @bitwise_and(left,right);
-};
-
-__bitwise_and__ :: (left:i32,right:i32) -> i32 {
-  return @bitwise_and(left,right);
-};
-
-__bitwise_and__ :: (left:u64,right:u64) -> u64 {
-  return @bitwise_and(left,right);
-};
-
-__bitwise_and__ :: (left:i64,right:i64) -> i64 {
-  return @bitwise_and(left,right);
-};
-
-__bitwise_xor__ :: (left:u8,right:u8) -> u8 {
-  return @bitwise_xor(left,right);
-};
-
-__bitwise_xor__ :: (left:i8,right:i8) -> i8 {
-  return @bitwise_xor(left,right);
-};
-
-__bitwise_xor__ :: (left:u16,right:u16) -> u16 {
-  return @bitwise_xor(left,right);
-};
-
-__bitwise_xor__ :: (left:i16,right:i16) -> i16 {
-  return @bitwise_xor(left,right);
-};
-
-__bitwise_xor__ :: (left:u32,right:u32) -> u32 {
-  return @bitwise_xor(left,right);
-};
-
-__bitwise_xor__ :: (left:i32,right:i32) -> i32 {
-  return @bitwise_xor(left,right);
-};
-
-__bitwise_xor__ :: (left:u64,right:u64) -> u64 {
-  return @bitwise_xor(left,right);
-};
-
-__bitwise_xor__ :: (left:i64,right:i64) -> i64 {
-  return @bitwise_xor(left,right);
-};
-
-__bitwise_or__ :: (left:u8,right:u8) -> u8 {
-  return @bitwise_or(left,right);
-};
-
-__bitwise_or__ :: (left:i8,right:i8) -> i8 {
-  return @bitwise_or(left,right);
-};
-
-__bitwise_or__ :: (left:u16,right:u16) -> u16 {
-  return @bitwise_or(left,right);
-};
-
-__bitwise_or__ :: (left:i16,right:i16) -> i16 {
-  return @bitwise_or(left,right);
-};
-
-__bitwise_or__ :: (left:u32,right:u32) -> u32 {
-  return @bitwise_or(left,right);
-};
-
-__bitwise_or__ :: (left:i32,right:i32) -> i32 {
-  return @bitwise_or(left,right);
-};
-
-__bitwise_or__ :: (left:u64,right:u64) -> u64 {
-  return @bitwise_or(left,right);
-};
-
-__bitwise_or__ :: (left:i64,right:i64) -> i64 {
-  return @bitwise_or(left,right);
-};
-
-__shift_left__ :: (left:u8,right:u8) -> u8 {
-  return @shift_left(left,right);
-};
-
-__shift_left__ :: (left:i8,right:i8) -> i8 {
-  return @shift_left(left,right);
-};
-
-__shift_left__ :: (left:u16,right:u16) -> u16 {
-  return @shift_left(left,right);
-};
-
-__shift_left__ :: (left:i16,right:i16) -> i16 {
-  return @shift_left(left,right);
-};
-
-__shift_left__ :: (left:u32,right:u32) -> u32 {
-  return @shift_left(left,right);
-};
-
-__shift_left__ :: (left:i32,right:i32) -> i32 {
-  return @shift_left(left,right);
-};
-
-__shift_left__ :: (left:u64,right:u64) -> u64 {
-  return @shift_left(left,right);
-};
-
-__shift_left__ :: (left:i64,right:i64) -> i64 {
-  return @shift_left(left,right);
-};
-
-__shift_right__ :: (left:u8,right:u8) -> u8 {
-  return @shift_right(left,right);
-};
-
-__shift_right__ :: (left:i8,right:i8) -> i8 {
-  return @shift_right(left,right);
-};
-
-__shift_right__ :: (left:u16,right:u16) -> u16 {
-  return @shift_right(left,right);
-};
-
-__shift_right__ :: (left:i16,right:i16) -> i16 {
-  return @shift_right(left,right);
-};
-
-__shift_right__ :: (left:u32,right:u32) -> u32 {
-  return @shift_right(left,right);
-};
-
-__shift_right__ :: (left:i32,right:i32) -> i32 {
-  return @shift_right(left,right);
-};
-
-__shift_right__ :: (left:u64,right:u64) -> u64 {
-  return @shift_right(left,right);
-};
-
-__shift_right__ :: (left:i64,right:i64) -> i64 {
-  return @shift_right(left,right);
-};
-
+@import("lib/operator.felan");
+@import("lib/types.felan");
+@import("lib/io.felan");
diff --git a/code/lib/io.felan b/code/lib/io.felan
new file mode 100644
index 0000000..dfc0aaa
--- /dev/null
+++ b/code/lib/io.felan
@@ -0,0 +1,73 @@
+@import("types.felan");
+@import("operator.felan");
+
+libc :: @c_library("/lib/libc.so.6");
+puts :: @c_function(libc,"puts",(*u8)->i32);
+putchar :: @c_function(libc,"putchar",(i32)->void);
+
+print :: (value:string) -> void {
+  i :u64= 0;
+  while i < value.length {
+    print_char(value[i]);
+  }
+};
+
+print_char :: (value:u8) -> void {
+  putchar(@cast(value,i32));
+};
+
+print :: (value:i8) -> void {
+  _print_signed(@type_of(value),value);
+};
+
+print :: (value:u8) -> void {
+  _print_unsigned(@type_of(value),value);
+};
+
+print :: (value:i16) -> void {
+  _print_signed(@type_of(value),value);
+};
+
+print :: (value:u16) -> void {
+  _print_unsigned(@type_of(value),value);
+};
+
+print :: (value:i32) -> void {
+  _print_signed(@type_of(value),value);
+};
+
+print :: (value:u32) -> void {
+  _print_unsigned(@type_of(value),value);
+};
+
+print :: (value:i64) -> void {
+  _print_signed(@type_of(value),value);
+};
+
+print :: (value:u64) -> void {
+  _print_unsigned(@type_of(value),value);
+};
+
+_print_signed :: (comptime t:type, value:t) -> i32 {
+  if value < @cast(0,t) {
+    putchar(@cast('-',i32));
+    value = -value;
+  }
+  _print_unsigned(t,value);
+};
+
+_print_unsigned :: (comptime t:type, value:t) -> void {
+  NUMBERS_SIZE :: 21;
+  numbers : [NUMBERS_SIZE]u8 = undefined;
+  i := NUMBERS_SIZE - 1;
+  numbers[i] = '\0';
+
+  while {
+    i -= 1;
+    numbers[i] = @cast(value%@cast(10,t),u8)+'0';
+    value /= @cast(10,t);
+    value != @cast(0,t);
+  } {}
+
+  puts(&numbers[i]);
+};
diff --git a/code/lib/operator.felan b/code/lib/operator.felan
new file mode 100644
index 0000000..d8121c2
--- /dev/null
+++ b/code/lib/operator.felan
@@ -0,0 +1,792 @@
+__plus__ :: (value:u8) -> u8 {
+  return value;
+};
+
+__plus__ :: (value:i8) -> i8 {
+  return value;
+};
+
+__plus__ :: (value:u16) -> u16 {
+  return value;
+};
+
+__plus__ :: (value:i16) -> i16 {
+  return value;
+};
+
+__plus__ :: (value:u32) -> u32 {
+  return value;
+};
+
+__plus__ :: (value:i32) -> i32 {
+  return value;
+};
+
+__plus__ :: (value:u64) -> u64 {
+  return value;
+};
+
+__plus__ :: (value:i64) -> i64 {
+  return value;
+};
+
+__minus__ :: (value:i8) -> i8 {
+  return @neg(value);
+};
+
+__minus__ :: (value:i16) -> i16 {
+  return @neg(value);
+};
+
+__minus__ :: (value:i32) -> i32 {
+  return @neg(value);
+};
+
+__minus__ :: (value:i64) -> i64 {
+  return @neg(value);
+};
+
+__sum__ :: (left:u8,right:u8) -> u8 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:i8,right:i8) -> i8 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:u16,right:u16) -> u16 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:i16,right:i16) -> i16 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:u32,right:u32) -> u32 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:i32,right:i32) -> i32 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:u64,right:u64) -> u64 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:i64,right:i64) -> i64 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:f16,right:f16) -> f16 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:f32,right:f32) -> f32 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:f64,right:f64) -> f64 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:f128,right:f128) -> f128 {
+  return @add(left,right);
+};
+
+__sub__ :: (left:u8,right:u8) -> u8 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:i8,right:i8) -> i8 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:u16,right:u16) -> u16 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:i16,right:i16) -> i16 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:u32,right:u32) -> u32 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:i32,right:i32) -> i32 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:u64,right:u64) -> u64 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:i64,right:i64) -> i64 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:f16,right:f16) -> f16 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:f32,right:f32) -> f32 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:f64,right:f64) -> f64 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:f128,right:f128) -> f128 {
+  return @sub(left,right);
+};
+
+__mul__ :: (left:u8,right:u8) -> u8 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:i8,right:i8) -> i8 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:u16,right:u16) -> u16 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:i16,right:i16) -> i16 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:u32,right:u32) -> u32 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:i32,right:i32) -> i32 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:u64,right:u64) -> u64 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:i64,right:i64) -> i64 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:f16,right:f16) -> f16 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:f32,right:f32) -> f32 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:f64,right:f64) -> f64 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:f128,right:f128) -> f128 {
+  return @mul(left,right);
+};
+
+__div__ :: (left:u8,right:u8) -> u8 {
+  return @div(left,right);
+};
+
+__div__ :: (left:i8,right:i8) -> i8 {
+  return @div(left,right);
+};
+
+__div__ :: (left:u16,right:u16) -> u16 {
+  return @div(left,right);
+};
+
+__div__ :: (left:i16,right:i16) -> i16 {
+  return @div(left,right);
+};
+
+__div__ :: (left:u32,right:u32) -> u32 {
+  return @div(left,right);
+};
+
+__div__ :: (left:i32,right:i32) -> i32 {
+  return @div(left,right);
+};
+
+__div__ :: (left:u64,right:u64) -> u64 {
+  return @div(left,right);
+};
+
+__div__ :: (left:i64,right:i64) -> i64 {
+  return @div(left,right);
+};
+
+__div__ :: (left:f16,right:f16) -> f16 {
+  return @div(left,right);
+};
+
+__div__ :: (left:f32,right:f32) -> f32 {
+  return @div(left,right);
+};
+
+__div__ :: (left:f64,right:f64) -> f64 {
+  return @div(left,right);
+};
+
+__div__ :: (left:f128,right:f128) -> f128 {
+  return @div(left,right);
+};
+
+__mod__ :: (left:u8,right:u8) -> u8 {
+  return @mod(left,right);
+};
+
+__mod__ :: (left:i8,right:i8) -> i8 {
+  return @mod(left,right);
+};
+
+__mod__ :: (left:u16,right:u16) -> u16 {
+  return @mod(left,right);
+};
+
+__mod__ :: (left:i16,right:i16) -> i16 {
+  return @mod(left,right);
+};
+
+__mod__ :: (left:u32,right:u32) -> u32 {
+  return @mod(left,right);
+};
+
+__mod__ :: (left:i32,right:i32) -> i32 {
+  return @mod(left,right);
+};
+
+__mod__ :: (left:u64,right:u64) -> u64 {
+  return @mod(left,right);
+};
+
+__mod__ :: (left:i64,right:i64) -> i64 {
+  return @mod(left,right);
+};
+
+__greater__ :: (left:u8,right:u8) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:i8,right:i8) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:u16,right:u16) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:i16,right:i16) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:u32,right:u32) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:i32,right:i32) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:u64,right:u64) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:i64,right:i64) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:f16,right:f16) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:f32,right:f32) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:f64,right:f64) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:f128,right:f128) -> bool {
+  return @greater(left,right);
+};
+
+__smaller__ :: (left:u8,right:u8) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:i8,right:i8) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:u16,right:u16) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:i16,right:i16) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:u32,right:u32) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:i32,right:i32) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:u64,right:u64) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:i64,right:i64) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:f16,right:f16) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:f32,right:f32) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:f64,right:f64) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:f128,right:f128) -> bool {
+  return @smaller(left,right);
+};
+
+__greater_or_equal__ :: (left:u8,right:u8) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:i8,right:i8) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:u16,right:u16) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:i16,right:i16) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:u32,right:u32) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:i32,right:i32) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:u64,right:u64) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:i64,right:i64) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:f16,right:f16) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:f32,right:f32) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:f64,right:f64) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:f128,right:f128) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:u8,right:u8) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:i8,right:i8) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:u16,right:u16) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:i16,right:i16) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:u32,right:u32) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:i32,right:i32) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:u64,right:u64) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:i64,right:i64) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:f16,right:f16) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:f32,right:f32) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:f64,right:f64) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:f128,right:f128) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__equal__ :: (left:u8,right:u8) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:i8,right:i8) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:u16,right:u16) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:i16,right:i16) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:u32,right:u32) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:i32,right:i32) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:u64,right:u64) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:i64,right:i64) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:f16,right:f16) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:f32,right:f32) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:f64,right:f64) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:f128,right:f128) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:bool,right:bool) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:type,right:type) -> bool {
+  return @equal(left,right);
+};
+
+__not_equal__ :: (left:u8,right:u8) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:i8,right:i8) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:u16,right:u16) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:i16,right:i16) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:u32,right:u32) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:i32,right:i32) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:u64,right:u64) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:i64,right:i64) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:f16,right:f16) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:f32,right:f32) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:f64,right:f64) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:f128,right:f128) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:bool,right:bool) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:type,right:type) -> bool {
+  return @not_equal(left,right);
+};
+
+__logical_not__ :: (value:bool) -> bool {
+  return value == false;
+};
+
+__logical_and__ :: (left:bool,lazy right:bool) -> bool {
+  if left == false {
+    return false;
+  } else if right == false {
+    return false;
+  } else {
+    return true;
+  }
+};
+
+__logical_or__ :: (left:bool,lazy right:bool) -> bool {
+  if left == true {
+    return true;
+  } else if right == true {
+    return true;
+  } else {
+    return false;
+  }
+};
+
+__bitwise_not__ :: (value:u8) -> u8 {
+  return @bitwise_not(value);
+};
+
+__bitwise_not__ :: (value:i8) -> i8 {
+  return @bitwise_not(value);
+};
+
+__bitwise_not__ :: (value:u16) -> u16 {
+  return @bitwise_not(value);
+};
+
+__bitwise_not__ :: (value:i16) -> i16 {
+  return @bitwise_not(value);
+};
+
+__bitwise_not__ :: (value:u32) -> u32 {
+  return @bitwise_not(value);
+};
+
+__bitwise_not__ :: (value:i32) -> i32 {
+  return @bitwise_not(value);
+};
+
+__bitwise_not__ :: (value:u64) -> u64 {
+  return @bitwise_not(value);
+};
+
+__bitwise_not__ :: (value:i64) -> i64 {
+  return @bitwise_not(value);
+};
+
+__bitwise_and__ :: (left:u8,right:u8) -> u8 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_and__ :: (left:i8,right:i8) -> i8 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_and__ :: (left:u16,right:u16) -> u16 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_and__ :: (left:i16,right:i16) -> i16 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_and__ :: (left:u32,right:u32) -> u32 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_and__ :: (left:i32,right:i32) -> i32 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_and__ :: (left:u64,right:u64) -> u64 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_and__ :: (left:i64,right:i64) -> i64 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_xor__ :: (left:u8,right:u8) -> u8 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_xor__ :: (left:i8,right:i8) -> i8 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_xor__ :: (left:u16,right:u16) -> u16 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_xor__ :: (left:i16,right:i16) -> i16 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_xor__ :: (left:u32,right:u32) -> u32 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_xor__ :: (left:i32,right:i32) -> i32 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_xor__ :: (left:u64,right:u64) -> u64 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_xor__ :: (left:i64,right:i64) -> i64 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_or__ :: (left:u8,right:u8) -> u8 {
+  return @bitwise_or(left,right);
+};
+
+__bitwise_or__ :: (left:i8,right:i8) -> i8 {
+  return @bitwise_or(left,right);
+};
+
+__bitwise_or__ :: (left:u16,right:u16) -> u16 {
+  return @bitwise_or(left,right);
+};
+
+__bitwise_or__ :: (left:i16,right:i16) -> i16 {
+  return @bitwise_or(left,right);
+};
+
+__bitwise_or__ :: (left:u32,right:u32) -> u32 {
+  return @bitwise_or(left,right);
+};
+
+__bitwise_or__ :: (left:i32,right:i32) -> i32 {
+  return @bitwise_or(left,right);
+};
+
+__bitwise_or__ :: (left:u64,right:u64) -> u64 {
+  return @bitwise_or(left,right);
+};
+
+__bitwise_or__ :: (left:i64,right:i64) -> i64 {
+  return @bitwise_or(left,right);
+};
+
+__shift_left__ :: (left:u8,right:u8) -> u8 {
+  return @shift_left(left,right);
+};
+
+__shift_left__ :: (left:i8,right:i8) -> i8 {
+  return @shift_left(left,right);
+};
+
+__shift_left__ :: (left:u16,right:u16) -> u16 {
+  return @shift_left(left,right);
+};
+
+__shift_left__ :: (left:i16,right:i16) -> i16 {
+  return @shift_left(left,right);
+};
+
+__shift_left__ :: (left:u32,right:u32) -> u32 {
+  return @shift_left(left,right);
+};
+
+__shift_left__ :: (left:i32,right:i32) -> i32 {
+  return @shift_left(left,right);
+};
+
+__shift_left__ :: (left:u64,right:u64) -> u64 {
+  return @shift_left(left,right);
+};
+
+__shift_left__ :: (left:i64,right:i64) -> i64 {
+  return @shift_left(left,right);
+};
+
+__shift_right__ :: (left:u8,right:u8) -> u8 {
+  return @shift_right(left,right);
+};
+
+__shift_right__ :: (left:i8,right:i8) -> i8 {
+  return @shift_right(left,right);
+};
+
+__shift_right__ :: (left:u16,right:u16) -> u16 {
+  return @shift_right(left,right);
+};
+
+__shift_right__ :: (left:i16,right:i16) -> i16 {
+  return @shift_right(left,right);
+};
+
+__shift_right__ :: (left:u32,right:u32) -> u32 {
+  return @shift_right(left,right);
+};
+
+__shift_right__ :: (left:i32,right:i32) -> i32 {
+  return @shift_right(left,right);
+};
+
+__shift_right__ :: (left:u64,right:u64) -> u64 {
+  return @shift_right(left,right);
+};
+
+__shift_right__ :: (left:i64,right:i64) -> i64 {
+  return @shift_right(left,right);
+};
+
diff --git a/code/lib/types.felan b/code/lib/types.felan
new file mode 100644
index 0000000..8c0cbf1
--- /dev/null
+++ b/code/lib/types.felan
@@ -0,0 +1,8 @@
+string :: []u8;
+
+array :: (comptime size:u64, comptime t:type) -> type {
+  return struct {
+    ptr : t;
+    size : i32 : size;
+  };
+};
diff --git a/code/main.felan b/code/main.felan
index 6d83f56..9f49f01 100644
--- a/code/main.felan
+++ b/code/main.felan
@@ -12,8 +12,10 @@ WindowShouldClose :: @c_function(raylib,"WindowShouldClose",()->bool);
 BeginDrawing :: @c_function(raylib,"BeginDrawing",()->void);
 EndDrawing :: @c_function(raylib,"EndDrawing",()->void);
 CloseWindow :: @c_function(raylib,"CloseWindow",()->void);
-ClearBackground :: @c_function(raylib,"ClearBackground",(color:Color)->void);
-DrawText :: @c_function(raylib,"DrawText",(*u8,i32,i32,i32,u32)->void);
+ClearBackground :: @c_function(raylib,"ClearBackground",(Color)->void);
+DrawText :: @c_function(raylib,"DrawText",(*u8,i32,i32,i32,Color)->void);
+// void DrawRectangle(int posX, int posY, int width, int height, Color color); 
+DrawRectangle :: @c_function(raylib,"DrawRectangle",(posX:i32,posY:i32,width:i32,height:i32,color:Color)->void);
 
 Color :: struct {
   r:u8;
@@ -23,6 +25,8 @@ Color :: struct {
 };
 
 main :: ()->void{
+  print(1236);
+  return;
   b := "raylib [core] example - basic window\0";
   c := "Congrats! You created your first window!\0";
   str := &b[0];
@@ -31,14 +35,21 @@ main :: ()->void{
   screenHeight :i32: 450;
   a : u8 : 255;
   b : u8 : 0;
-  white :: color(a,a,a,a);
-  black :u32= 0xff000000;
+  WHITE :: color(a,a,a,a);
+  BLACK :: color(@cast(0xff0000ff,u32));
   InitWindow(screenWidth,screenHeight,str);
+  rect_posx :i32= 0;
+  rect_posy :i32= 0;
   while !WindowShouldClose() {
     BeginDrawing();
-    ClearBackground(white);
-    DrawText(str2,@cast(190,i32),@cast(200,i32),@cast(20,i32),black);
+    ClearBackground(WHITE);
+    DrawRectangle(rect_posx,rect_posy,@cast(200,i32),@cast(40,i32),color(@cast(0x00ffff,u32)));
+    DrawText(str2,@cast(190,i32),@cast(200,i32),@cast(20,i32),BLACK);
     EndDrawing();
+    /*
+    rect_posx += @cast(1,i32);
+    rect_posy += @cast(1,i32);
+    */
   }
   CloseWindow();
 };
@@ -51,3 +62,12 @@ color :: (a:u8,r:u8,g:u8,b:u8)->Color{
   c.a = a;
   return c;
 };
+
+color :: (value:u32)->Color{
+  c : Color = undefined;
+  c.r = @cast((value&@cast(0xff000000,u32))>>@cast(6*4,u32),u8);
+  c.g = @cast((value&@cast(0x00ff0000,u32))>>@cast(4*4,u32),u8);
+  c.b = @cast((value&@cast(0x0000ff00,u32))>>@cast(2*4,u32),u8);
+  c.a = @cast((value&@cast(0x000000ff,u32))>>@cast(0*4,u32),u8);
+  return c;
+};
diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index 0b4bc63..fc9217e 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -5639,9 +5639,12 @@ bool setTypesFunctionCall(AstTree *tree, AstTreeSetTypesHelper _helper) {
 
         AstTreeFunctionCallParam p0 = metadata->parameters[i];
         AstTreeFunctionCallParam p1 = call->parameters[i];
-        AstTree *v0 = getValue(p0.value, false);
-        AstTree *v1 = getValue(p1.value, false);
-        if (!isEqual(v0, v1)) {
+        AstTree *v0 = getValue(p0.value, true);
+        AstTree *v1 = getValue(p1.value, true);
+        bool res = isEqual(v0, v1);
+        astTreeDelete(v0);
+        astTreeDelete(v1);
+        if (!res) {
           goto SEARCH_LOOP_CONTINUE;
         }
       }
diff --git a/src/runner/runner.c b/src/runner/runner.c
index b41e0db..a952c0b 100644
--- a/src/runner/runner.c
+++ b/src/runner/runner.c
@@ -1418,13 +1418,11 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
     astTreeDelete(condition);
     AstTree *ret;
     if (condi) {
-      ret =
-          runExpression(metadata->ifBody, scope, shouldRet, isLeft, isComptime,
-                        breakCount, shouldContinue, false);
+      ret = runExpression(metadata->ifBody, scope, shouldRet, isLeft,
+                          isComptime, breakCount, shouldContinue, false);
     } else if (metadata->elseBody != NULL) {
-      ret =
-          runExpression(metadata->elseBody, scope, shouldRet, isLeft,
-                        isComptime, breakCount, shouldContinue, false);
+      ret = runExpression(metadata->elseBody, scope, shouldRet, isLeft,
+                          isComptime, breakCount, shouldContinue, false);
     } else {
       ret = &AST_TREE_VOID_VALUE;
     }
@@ -1472,10 +1470,9 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
     AstTree *ret = &AST_TREE_VOID_VALUE;
     for (size_t i = 0; i < metadata->expressions_size && !*shouldRet; ++i) {
       astTreeDelete(ret);
-      ret =
-          runExpression(metadata->expressions[i], scope, shouldRet,
-                        i == metadata->expressions_size - 1 && isLeft,
-                        isComptime, breakCount, shouldContinue, false);
+      ret = runExpression(metadata->expressions[i], scope, shouldRet,
+                          i == metadata->expressions_size - 1 && isLeft,
+                          isComptime, breakCount, shouldContinue, false);
       if (discontinue(*shouldRet, *breakCount)) {
         return ret;
       }
@@ -1502,9 +1499,9 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
 
     for (size_t i = 0; i < 1; ++i) {
       AstTreeVariable *arg = fun->arguments.data[i];
-      arguments[i] = getForVariable(arguments[i], scope, shouldRet, isLeft,
-                                    isComptime, breakCount, shouldContinue,
-                                    arg->isLazy, false);
+      arguments[i] =
+          getForVariable(arguments[i], scope, shouldRet, isLeft, isComptime,
+                         breakCount, shouldContinue, arg->isLazy, false);
       if (discontinue(*shouldRet, *breakCount)) {
         astTreeDelete(function);
         for (size_t j = 0; j < i; ++j) {
@@ -1553,9 +1550,9 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
 
     for (size_t i = 0; i < 2; ++i) {
       AstTreeVariable *arg = fun->arguments.data[i];
-      arguments[i] = getForVariable(arguments[i], scope, shouldRet, isLeft,
-                                    isComptime, breakCount, shouldContinue,
-                                    arg->isLazy, false);
+      arguments[i] =
+          getForVariable(arguments[i], scope, shouldRet, isLeft, isComptime,
+                         breakCount, shouldContinue, arg->isLazy, false);
       if (discontinue(*shouldRet, *breakCount)) {
         astTreeDelete(function);
         for (size_t j = 0; j < i; ++j) {
@@ -1649,6 +1646,7 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
     }
 
     if (operand->token != AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED) {
+      printLog("%s", AST_TREE_TOKEN_STRINGS[operand->token]);
       UNREACHABLE;
     }