diff --git a/base.cpp b/base.cpp
index 1ec739f..c89f813 100644
--- a/base.cpp
+++ b/base.cpp
@@ -138,6 +138,7 @@ typedef double   F64;
 #define JOIN(X,Y) JOIN1(X,Y)
 #define string_expand(x) (int)x.len, x.str
 
+#define CORE_STRINGS
 struct String{
   U8 *str;
   S64 len;
@@ -154,78 +155,6 @@ global String string_null = {(U8 *)"null", 4};
 #include "stb_sprintf.h"
 #define snprintf stbsp_snprintf
 
-
-union Vec2 {
-  struct { F32 x, y; };
-  struct { F32 width, height; };
-  F32 p[2];
-};
-
-union Vec3 {
-  struct{ F32 x, y, z; };
-  struct{ F32 r, g, b; };
-  struct{ Vec2 xy; F32 z_; };
-  struct{ F32 x_; Vec2 yz; };
-  F32 p[3];
-};
-
-union Vec4 {
-  struct{ F32 x, y, z, w; };
-  struct{ F32 r, g, b, a; };
-  struct{ Vec2 xy;  Vec2 zw;  };
-  struct{ Vec2 xy_; F32 width, height; };
-  struct{ Vec3 xyz; F32 w_; };
-  struct{ F32 x_; Vec3 yzw; };
-  struct{ Vec3 rgb; F32 a_; };
-  F32 p[4];
-};
-
-struct Mat4 {
-  F32 p[4][4];
-};
-
-union Vec1I {
-  S32 x;
-  S32 p[1];
-};
-
-union Vec2I {
-  struct { S32 x, y; };
-  struct { S32 width, height; };
-  S32 p[2];
-};
-
-union Vec3I {
-  struct { S32 x, y, z; };
-  struct { S32 r, g, b; };
-  struct { Vec2I xy; S32 z_; };
-  struct { S32 x_; Vec2I yz; };
-  S32 p[3];
-};
-
-union Vec4I {
-  struct { S32 x, y, z, w; };
-  struct { S32 r, g, b, a; };
-  struct { Vec2I xy;  Vec2I zw; };
-  struct { Vec2I xy_; S32 width, height; };
-  struct { Vec3I xyz; S32 w_; };
-  struct { S32 x_; Vec3I yzw; };
-  struct { Vec3I rgb; S32 a_; };
-  S32 p[4];
-};
-
-union Rect2 {
-  struct {F32 min_x, min_y, max_x, max_y;};
-  struct { Vec2 min; Vec2 max; };
-  F32 p[4];
-};
-
-union Rect2I {
-  struct { S32 min_x, min_y, max_x, max_y;};
-  struct { Vec2I min; Vec2I max; };
-  S32 p[4];
-};
-
 //-----------------------------------------------------------------------------
 // Utilities
 //-----------------------------------------------------------------------------
diff --git a/base_math.cpp b/base_math.cpp
deleted file mode 100644
index 9d98054..0000000
--- a/base_math.cpp
+++ /dev/null
@@ -1,1714 +0,0 @@
-#pragma once
-
-///////////////////////////////////////
-// @Section Math
-#include <math.h>
-constexpr F32 PI32 = 3.14159265359f;
-
-api F32 power(S64 pow, F32 value) {
-  F32 result = value;
-  if (pow == 0) {
-    result = 1;
-  } else {
-    for (S64 i = 1; i < pow; i++) {
-      result *= result;
-    }
-  }
-  return result;
-}
-
-api F32 to_radians(F32 degrees) {
-  F32 result = degrees * (PI32 / 180.f);
-  return result;
-}
-
-api F32 to_degrees(F32 radians) {
-  F32 result = radians * (180.f / PI32);
-  return result;
-}
-
-api F32 fraction(F32 value) {
-  F32 result = value - floorf(value);
-  return result;
-}
-
-api F32 absolute(F32 value) {
-  if (value < 0)
-    value = -value;
-  return value;
-}
-
-api S32 square(S32 val) {
-  return val * val;
-}
-
-api S32 clamp01(S32 val) {
-  S32 result = clamp(0, val, 1);
-  return result;
-}
-
-api S32 sign(S32 val) {
-  if (val > 0)
-    return 1;
-  else if (val < 0)
-    return -1;
-  return 0;
-}
-
-api F32 square(F32 val) { return val * val; }
-
-api F32 clamp01(F32 val) {
-  F32 result = clamp(0.f, val, 1.f);
-  return result;
-}
-
-api F32 sign(F32 val) {
-  if (val > 0)
-    return 1;
-  else if (val < 0)
-    return -1;
-  return 0;
-}
-
-api F32 floor(F32 val) { return floorf(val); }
-
-api F32 ceil(F32 val) { return ceilf(val); }
-
-api F32 round(F32 val) { return roundf(val); }
-
-api F32 sine(F32 val) { return sinf(val); }
-
-api F32 sine01(F32 val) {
-  F32 result = sine(val);
-  result += 1;
-  result /= 2;
-  return result;
-}
-
-api F32 cosine(F32 val) { return cosf(val); }
-
-api F32 square_root(F32 val) { return sqrtf(val); }
-
-api Vec2 vec2(F32 x, F32 y) {
-  Vec2 result;
-  result.x = x;
-  result.y = y;
-  return result;
-}
-api Vec2 vec2() { return vec2(0, 0); }
-api Vec2 operator+(Vec2 a, Vec2 b) {
-  Vec2 result = vec2(a.x + b.x, a.y + b.y);
-  return result;
-}
-api Vec2 operator+(Vec2 a, F32 b) {
-  Vec2 result = vec2(a.x + b, a.y + b);
-  return result;
-}
-api Vec2 operator+(F32 a, Vec2 b) {
-  Vec2 result = vec2(a + b.x, a + b.y);
-  return result;
-}
-api Vec2 &operator+=(Vec2 &a, Vec2 b) {
-  a = a + b;
-  return a;
-}
-api Vec2 &operator+=(Vec2 &a, F32 b) {
-  a = a + b;
-  return a;
-}
-api Vec2 operator-(Vec2 a, Vec2 b) {
-  Vec2 result = vec2(a.x - b.x, a.y - b.y);
-  return result;
-}
-api Vec2 operator-(Vec2 a, F32 b) {
-  Vec2 result = vec2(a.x - b, a.y - b);
-  return result;
-}
-api Vec2 operator-(F32 a, Vec2 b) {
-  Vec2 result = vec2(a - b.x, a - b.y);
-  return result;
-}
-api Vec2 &operator-=(Vec2 &a, Vec2 b) {
-  a = a - b;
-  return a;
-}
-api Vec2 &operator-=(Vec2 &a, F32 b) {
-  a = a - b;
-  return a;
-}
-api Vec2 operator*(Vec2 a, Vec2 b) {
-  Vec2 result = vec2(a.x * b.x, a.y * b.y);
-  return result;
-}
-api Vec2 operator*(Vec2 a, F32 b) {
-  Vec2 result = vec2(a.x * b, a.y * b);
-  return result;
-}
-api Vec2 operator*(F32 a, Vec2 b) {
-  Vec2 result = vec2(a * b.x, a * b.y);
-  return result;
-}
-api Vec2 &operator*=(Vec2 &a, Vec2 b) {
-  a = a * b;
-  return a;
-}
-api Vec2 &operator*=(Vec2 &a, F32 b) {
-  a = a * b;
-  return a;
-}
-api Vec2 operator/(Vec2 a, Vec2 b) {
-  Vec2 result = vec2(a.x / b.x, a.y / b.y);
-  return result;
-}
-api Vec2 operator/(Vec2 a, F32 b) {
-  Vec2 result = vec2(a.x / b, a.y / b);
-  return result;
-}
-api Vec2 operator/(F32 a, Vec2 b) {
-  Vec2 result = vec2(a / b.x, a / b.y);
-  return result;
-}
-api Vec2 &operator/=(Vec2 &a, Vec2 b) {
-  a = a / b;
-  return a;
-}
-api Vec2 &operator/=(Vec2 &a, F32 b) {
-  a = a / b;
-  return a;
-}
-api B32 operator!=(Vec2 a, Vec2 b) {
-  B32 result = (a.x != b.x) || (a.y != b.y);
-  return result;
-}
-api B32 operator==(Vec2 a, Vec2 b) {
-  B32 result = (a.x == b.x) && (a.y == b.y);
-  return result;
-}
-api Vec2 operator-(Vec2 a) {
-  Vec2 result = vec2(-a.x, -a.y);
-  return result;
-}
-api Vec2 clamp(Vec2 min, Vec2 val, Vec2 max) {
-  Vec2 result = vec2(clamp(min.x, val.x, max.x), clamp(min.y, val.y, max.y));
-  return result;
-}
-api Vec2 clamp(F32 min, Vec2 val, F32 max) {
-  Vec2 result = vec2(clamp(min, val.x, max), clamp(min, val.y, max));
-  return result;
-}
-api Vec2 clamp01(Vec2 val) {
-  Vec2 result = vec2(clamp01(val.x), clamp01(val.y));
-  return result;
-}
-api Vec2 ceil(Vec2 a) {
-  Vec2 result = vec2(ceil(a.x), ceil(a.y));
-  return result;
-}
-api Vec2 floor(Vec2 a) {
-  Vec2 result = vec2(floor(a.x), floor(a.y));
-  return result;
-}
-api Vec2 round(Vec2 a) {
-  Vec2 result = vec2(round(a.x), round(a.y));
-  return result;
-}
-api Vec2 absolute(Vec2 a) {
-  Vec2 result = vec2(absolute(a.x), absolute(a.y));
-  return result;
-}
-api Vec2 sign(Vec2 a) {
-  Vec2 result = vec2(sign(a.x), sign(a.y));
-  return result;
-}
-api Vec2 fraction(Vec2 a) {
-  Vec2 result = vec2(fraction(a.x), fraction(a.y));
-  return result;
-}
-api Vec2 square(Vec2 a) {
-  Vec2 result = vec2(square(a.x), square(a.y));
-  return result;
-}
-api Vec2 square_root(Vec2 a) {
-  Vec2 result = vec2(square_root(a.x), square_root(a.y));
-  return result;
-}
-api F32 dot(Vec2 a, Vec2 b) {
-  F32 result = a.x * b.x + a.y * b.y;
-  return result;
-}
-api F32 length_squared(Vec2 a) {
-  F32 result = dot(a, a);
-  return result;
-}
-api F32 length(Vec2 a) {
-  F32 result = square_root(length_squared(a));
-  return result;
-}
-api Vec2 lerp(Vec2 from, Vec2 to, F32 t) {
-  Vec2 result = (1 - t) * from + to * t;
-  return result;
-}
-api Vec3 vec3(F32 x, F32 y, F32 z) {
-  Vec3 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  return result;
-}
-api Vec3 vec3() { return vec3(0, 0, 0); }
-api Vec3 operator+(Vec3 a, Vec3 b) {
-  Vec3 result = vec3(a.x + b.x, a.y + b.y, a.z + b.z);
-  return result;
-}
-api Vec3 operator+(Vec3 a, F32 b) {
-  Vec3 result = vec3(a.x + b, a.y + b, a.z + b);
-  return result;
-}
-api Vec3 operator+(F32 a, Vec3 b) {
-  Vec3 result = vec3(a + b.x, a + b.y, a + b.z);
-  return result;
-}
-api Vec3 &operator+=(Vec3 &a, Vec3 b) {
-  a = a + b;
-  return a;
-}
-api Vec3 &operator+=(Vec3 &a, F32 b) {
-  a = a + b;
-  return a;
-}
-api Vec3 operator-(Vec3 a, Vec3 b) {
-  Vec3 result = vec3(a.x - b.x, a.y - b.y, a.z - b.z);
-  return result;
-}
-api Vec3 operator-(Vec3 a, F32 b) {
-  Vec3 result = vec3(a.x - b, a.y - b, a.z - b);
-  return result;
-}
-api Vec3 operator-(F32 a, Vec3 b) {
-  Vec3 result = vec3(a - b.x, a - b.y, a - b.z);
-  return result;
-}
-api Vec3 &operator-=(Vec3 &a, Vec3 b) {
-  a = a - b;
-  return a;
-}
-api Vec3 &operator-=(Vec3 &a, F32 b) {
-  a = a - b;
-  return a;
-}
-api Vec3 operator*(Vec3 a, Vec3 b) {
-  Vec3 result = vec3(a.x * b.x, a.y * b.y, a.z * b.z);
-  return result;
-}
-api Vec3 operator*(Vec3 a, F32 b) {
-  Vec3 result = vec3(a.x * b, a.y * b, a.z * b);
-  return result;
-}
-api Vec3 operator*(F32 a, Vec3 b) {
-  Vec3 result = vec3(a * b.x, a * b.y, a * b.z);
-  return result;
-}
-api Vec3 &operator*=(Vec3 &a, Vec3 b) {
-  a = a * b;
-  return a;
-}
-api Vec3 &operator*=(Vec3 &a, F32 b) {
-  a = a * b;
-  return a;
-}
-api Vec3 operator/(Vec3 a, Vec3 b) {
-  Vec3 result = vec3(a.x / b.x, a.y / b.y, a.z / b.z);
-  return result;
-}
-api Vec3 operator/(Vec3 a, F32 b) {
-  Vec3 result = vec3(a.x / b, a.y / b, a.z / b);
-  return result;
-}
-api Vec3 operator/(F32 a, Vec3 b) {
-  Vec3 result = vec3(a / b.x, a / b.y, a / b.z);
-  return result;
-}
-api Vec3 &operator/=(Vec3 &a, Vec3 b) {
-  a = a / b;
-  return a;
-}
-api Vec3 &operator/=(Vec3 &a, F32 b) {
-  a = a / b;
-  return a;
-}
-api B32 operator!=(Vec3 a, Vec3 b) {
-  B32 result = (a.x != b.x) || (a.y != b.y) || (a.z != b.z);
-  return result;
-}
-api B32 operator==(Vec3 a, Vec3 b) {
-  B32 result = (a.x == b.x) && (a.y == b.y) && (a.z == b.z);
-  return result;
-}
-api Vec3 operator-(Vec3 a) {
-  Vec3 result = vec3(-a.x, -a.y, -a.z);
-  return result;
-}
-api Vec3 clamp(Vec3 min, Vec3 val, Vec3 max) {
-  Vec3 result = vec3(clamp(min.x, val.x, max.x), clamp(min.y, val.y, max.y), clamp(min.z, val.z, max.z));
-  return result;
-}
-api Vec3 clamp(F32 min, Vec3 val, F32 max) {
-  Vec3 result = vec3(clamp(min, val.x, max), clamp(min, val.y, max), clamp(min, val.z, max));
-  return result;
-}
-api Vec3 clamp01(Vec3 val) {
-  Vec3 result = vec3(clamp01(val.x), clamp01(val.y), clamp01(val.z));
-  return result;
-}
-api Vec3 ceil(Vec3 a) {
-  Vec3 result = vec3(ceil(a.x), ceil(a.y), ceil(a.z));
-  return result;
-}
-api Vec3 floor(Vec3 a) {
-  Vec3 result = vec3(floor(a.x), floor(a.y), floor(a.z));
-  return result;
-}
-api Vec3 round(Vec3 a) {
-  Vec3 result = vec3(round(a.x), round(a.y), round(a.z));
-  return result;
-}
-api Vec3 absolute(Vec3 a) {
-  Vec3 result = vec3(absolute(a.x), absolute(a.y), absolute(a.z));
-  return result;
-}
-api Vec3 sign(Vec3 a) {
-  Vec3 result = vec3(sign(a.x), sign(a.y), sign(a.z));
-  return result;
-}
-api Vec3 fraction(Vec3 a) {
-  Vec3 result = vec3(fraction(a.x), fraction(a.y), fraction(a.z));
-  return result;
-}
-api Vec3 square(Vec3 a) {
-  Vec3 result = vec3(square(a.x), square(a.y), square(a.z));
-  return result;
-}
-api Vec3 square_root(Vec3 a) {
-  Vec3 result = vec3(square_root(a.x), square_root(a.y), square_root(a.z));
-  return result;
-}
-api F32 dot(Vec3 a, Vec3 b) {
-  F32 result = a.x * b.x + a.y * b.y + a.z * b.z;
-  return result;
-}
-api F32 length_squared(Vec3 a) {
-  F32 result = dot(a, a);
-  return result;
-}
-api F32 length(Vec3 a) {
-  F32 result = square_root(length_squared(a));
-  return result;
-}
-api Vec3 lerp(Vec3 from, Vec3 to, F32 t) {
-  Vec3 result = (1 - t) * from + to * t;
-  return result;
-}
-api Vec4 vec4(F32 x, F32 y, F32 z, F32 w) {
-  Vec4 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-api Vec4 vec4() { return vec4(0, 0, 0, 0); }
-api Vec4 operator+(Vec4 a, Vec4 b) {
-  Vec4 result = vec4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
-  return result;
-}
-api Vec4 operator+(Vec4 a, F32 b) {
-  Vec4 result = vec4(a.x + b, a.y + b, a.z + b, a.w + b);
-  return result;
-}
-api Vec4 operator+(F32 a, Vec4 b) {
-  Vec4 result = vec4(a + b.x, a + b.y, a + b.z, a + b.w);
-  return result;
-}
-api Vec4 &operator+=(Vec4 &a, Vec4 b) {
-  a = a + b;
-  return a;
-}
-api Vec4 &operator+=(Vec4 &a, F32 b) {
-  a = a + b;
-  return a;
-}
-api Vec4 operator-(Vec4 a, Vec4 b) {
-  Vec4 result = vec4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
-  return result;
-}
-api Vec4 operator-(Vec4 a, F32 b) {
-  Vec4 result = vec4(a.x - b, a.y - b, a.z - b, a.w - b);
-  return result;
-}
-api Vec4 operator-(F32 a, Vec4 b) {
-  Vec4 result = vec4(a - b.x, a - b.y, a - b.z, a - b.w);
-  return result;
-}
-api Vec4 &operator-=(Vec4 &a, Vec4 b) {
-  a = a - b;
-  return a;
-}
-api Vec4 &operator-=(Vec4 &a, F32 b) {
-  a = a - b;
-  return a;
-}
-api Vec4 operator*(Vec4 a, Vec4 b) {
-  Vec4 result = vec4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
-  return result;
-}
-api Vec4 operator*(Vec4 a, F32 b) {
-  Vec4 result = vec4(a.x * b, a.y * b, a.z * b, a.w * b);
-  return result;
-}
-api Vec4 operator*(F32 a, Vec4 b) {
-  Vec4 result = vec4(a * b.x, a * b.y, a * b.z, a * b.w);
-  return result;
-}
-api Vec4 &operator*=(Vec4 &a, Vec4 b) {
-  a = a * b;
-  return a;
-}
-api Vec4 &operator*=(Vec4 &a, F32 b) {
-  a = a * b;
-  return a;
-}
-api Vec4 operator/(Vec4 a, Vec4 b) {
-  Vec4 result = vec4(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
-  return result;
-}
-api Vec4 operator/(Vec4 a, F32 b) {
-  Vec4 result = vec4(a.x / b, a.y / b, a.z / b, a.w / b);
-  return result;
-}
-api Vec4 operator/(F32 a, Vec4 b) {
-  Vec4 result = vec4(a / b.x, a / b.y, a / b.z, a / b.w);
-  return result;
-}
-api Vec4 &operator/=(Vec4 &a, Vec4 b) {
-  a = a / b;
-  return a;
-}
-api Vec4 &operator/=(Vec4 &a, F32 b) {
-  a = a / b;
-  return a;
-}
-api B32 operator!=(Vec4 a, Vec4 b) {
-  B32 result = (a.x != b.x) || (a.y != b.y) || (a.z != b.z) || (a.w != b.w);
-  return result;
-}
-api B32 operator==(Vec4 a, Vec4 b) {
-  B32 result = (a.x == b.x) && (a.y == b.y) && (a.z == b.z) && (a.w == b.w);
-  return result;
-}
-api Vec4 operator-(Vec4 a) {
-  Vec4 result = vec4(-a.x, -a.y, -a.z, -a.w);
-  return result;
-}
-api Vec4 clamp(Vec4 min, Vec4 val, Vec4 max) {
-  Vec4 result = vec4(clamp(min.x, val.x, max.x), clamp(min.y, val.y, max.y), clamp(min.z, val.z, max.z),
-                     clamp(min.w, val.w, max.w));
-  return result;
-}
-api Vec4 clamp(F32 min, Vec4 val, F32 max) {
-  Vec4 result =
-    vec4(clamp(min, val.x, max), clamp(min, val.y, max), clamp(min, val.z, max), clamp(min, val.w, max));
-  return result;
-}
-api Vec4 clamp01(Vec4 val) {
-  Vec4 result = vec4(clamp01(val.x), clamp01(val.y), clamp01(val.z), clamp01(val.w));
-  return result;
-}
-api Vec4 ceil(Vec4 a) {
-  Vec4 result = vec4(ceil(a.x), ceil(a.y), ceil(a.z), ceil(a.w));
-  return result;
-}
-api Vec4 floor(Vec4 a) {
-  Vec4 result = vec4(floor(a.x), floor(a.y), floor(a.z), floor(a.w));
-  return result;
-}
-api Vec4 round(Vec4 a) {
-  Vec4 result = vec4(round(a.x), round(a.y), round(a.z), round(a.w));
-  return result;
-}
-api Vec4 absolute(Vec4 a) {
-  Vec4 result = vec4(absolute(a.x), absolute(a.y), absolute(a.z), absolute(a.w));
-  return result;
-}
-api Vec4 sign(Vec4 a) {
-  Vec4 result = vec4(sign(a.x), sign(a.y), sign(a.z), sign(a.w));
-  return result;
-}
-api Vec4 fraction(Vec4 a) {
-  Vec4 result = vec4(fraction(a.x), fraction(a.y), fraction(a.z), fraction(a.w));
-  return result;
-}
-api Vec4 square(Vec4 a) {
-  Vec4 result = vec4(square(a.x), square(a.y), square(a.z), square(a.w));
-  return result;
-}
-api Vec4 square_root(Vec4 a) {
-  Vec4 result = vec4(square_root(a.x), square_root(a.y), square_root(a.z), square_root(a.w));
-  return result;
-}
-api F32 dot(Vec4 a, Vec4 b) {
-  F32 result = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
-  return result;
-}
-api F32 length_squared(Vec4 a) {
-  F32 result = dot(a, a);
-  return result;
-}
-api F32 length(Vec4 a) {
-  F32 result = square_root(length_squared(a));
-  return result;
-}
-api Vec4 lerp(Vec4 from, Vec4 to, F32 t) {
-  Vec4 result = (1 - t) * from + to * t;
-  return result;
-}
-api Vec2I vec2i(S32 x, S32 y) {
-  Vec2I result;
-  result.x = x;
-  result.y = y;
-  return result;
-}
-api Vec2I vec2i() { return vec2i(0, 0); }
-api Vec2I operator+(Vec2I a, Vec2I b) {
-  Vec2I result = vec2i(a.x + b.x, a.y + b.y);
-  return result;
-}
-api Vec2I operator+(Vec2I a, S32 b) {
-  Vec2I result = vec2i(a.x + b, a.y + b);
-  return result;
-}
-api Vec2I operator+(S32 a, Vec2I b) {
-  Vec2I result = vec2i(a + b.x, a + b.y);
-  return result;
-}
-api Vec2I &operator+=(Vec2I &a, Vec2I b) {
-  a = a + b;
-  return a;
-}
-api Vec2I &operator+=(Vec2I &a, S32 b) {
-  a = a + b;
-  return a;
-}
-api Vec2I operator-(Vec2I a, Vec2I b) {
-  Vec2I result = vec2i(a.x - b.x, a.y - b.y);
-  return result;
-}
-api Vec2I operator-(Vec2I a, S32 b) {
-  Vec2I result = vec2i(a.x - b, a.y - b);
-  return result;
-}
-api Vec2I operator-(S32 a, Vec2I b) {
-  Vec2I result = vec2i(a - b.x, a - b.y);
-  return result;
-}
-api Vec2I &operator-=(Vec2I &a, Vec2I b) {
-  a = a - b;
-  return a;
-}
-api Vec2I &operator-=(Vec2I &a, S32 b) {
-  a = a - b;
-  return a;
-}
-api Vec2I operator*(Vec2I a, Vec2I b) {
-  Vec2I result = vec2i(a.x * b.x, a.y * b.y);
-  return result;
-}
-api Vec2I operator*(Vec2I a, S32 b) {
-  Vec2I result = vec2i(a.x * b, a.y * b);
-  return result;
-}
-api Vec2I operator*(S32 a, Vec2I b) {
-  Vec2I result = vec2i(a * b.x, a * b.y);
-  return result;
-}
-api Vec2I &operator*=(Vec2I &a, Vec2I b) {
-  a = a * b;
-  return a;
-}
-api Vec2I &operator*=(Vec2I &a, S32 b) {
-  a = a * b;
-  return a;
-}
-api Vec2I operator/(Vec2I a, Vec2I b) {
-  Vec2I result = vec2i(a.x / b.x, a.y / b.y);
-  return result;
-}
-api Vec2I operator/(Vec2I a, S32 b) {
-  Vec2I result = vec2i(a.x / b, a.y / b);
-  return result;
-}
-api Vec2I operator/(S32 a, Vec2I b) {
-  Vec2I result = vec2i(a / b.x, a / b.y);
-  return result;
-}
-api Vec2I &operator/=(Vec2I &a, Vec2I b) {
-  a = a / b;
-  return a;
-}
-api Vec2I &operator/=(Vec2I &a, S32 b) {
-  a = a / b;
-  return a;
-}
-api B32 operator!=(Vec2I a, Vec2I b) {
-  B32 result = (a.x != b.x) || (a.y != b.y);
-  return result;
-}
-api B32 operator==(Vec2I a, Vec2I b) {
-  B32 result = (a.x == b.x) && (a.y == b.y);
-  return result;
-}
-api Vec2I operator-(Vec2I a) {
-  Vec2I result = vec2i(-a.x, -a.y);
-  return result;
-}
-api Vec2I clamp(Vec2I min, Vec2I val, Vec2I max) {
-  Vec2I result = vec2i(clamp(min.x, val.x, max.x), clamp(min.y, val.y, max.y));
-  return result;
-}
-api Vec2I clamp(S32 min, Vec2I val, S32 max) {
-  Vec2I result = vec2i(clamp(min, val.x, max), clamp(min, val.y, max));
-  return result;
-}
-api Vec2I clamp01(Vec2I val) {
-  Vec2I result = vec2i(clamp01(val.x), clamp01(val.y));
-  return result;
-}
-api Vec3I vec3i(S32 x, S32 y, S32 z) {
-  Vec3I result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  return result;
-}
-api Vec3I vec3i() { return vec3i(0, 0, 0); }
-api Vec3I operator+(Vec3I a, Vec3I b) {
-  Vec3I result = vec3i(a.x + b.x, a.y + b.y, a.z + b.z);
-  return result;
-}
-api Vec3I operator+(Vec3I a, S32 b) {
-  Vec3I result = vec3i(a.x + b, a.y + b, a.z + b);
-  return result;
-}
-api Vec3I operator+(S32 a, Vec3I b) {
-  Vec3I result = vec3i(a + b.x, a + b.y, a + b.z);
-  return result;
-}
-api Vec3I &operator+=(Vec3I &a, Vec3I b) {
-  a = a + b;
-  return a;
-}
-api Vec3I &operator+=(Vec3I &a, S32 b) {
-  a = a + b;
-  return a;
-}
-api Vec3I operator-(Vec3I a, Vec3I b) {
-  Vec3I result = vec3i(a.x - b.x, a.y - b.y, a.z - b.z);
-  return result;
-}
-api Vec3I operator-(Vec3I a, S32 b) {
-  Vec3I result = vec3i(a.x - b, a.y - b, a.z - b);
-  return result;
-}
-api Vec3I operator-(S32 a, Vec3I b) {
-  Vec3I result = vec3i(a - b.x, a - b.y, a - b.z);
-  return result;
-}
-api Vec3I &operator-=(Vec3I &a, Vec3I b) {
-  a = a - b;
-  return a;
-}
-api Vec3I &operator-=(Vec3I &a, S32 b) {
-  a = a - b;
-  return a;
-}
-api Vec3I operator*(Vec3I a, Vec3I b) {
-  Vec3I result = vec3i(a.x * b.x, a.y * b.y, a.z * b.z);
-  return result;
-}
-api Vec3I operator*(Vec3I a, S32 b) {
-  Vec3I result = vec3i(a.x * b, a.y * b, a.z * b);
-  return result;
-}
-api Vec3I operator*(S32 a, Vec3I b) {
-  Vec3I result = vec3i(a * b.x, a * b.y, a * b.z);
-  return result;
-}
-api Vec3I &operator*=(Vec3I &a, Vec3I b) {
-  a = a * b;
-  return a;
-}
-api Vec3I &operator*=(Vec3I &a, S32 b) {
-  a = a * b;
-  return a;
-}
-api Vec3I operator/(Vec3I a, Vec3I b) {
-  Vec3I result = vec3i(a.x / b.x, a.y / b.y, a.z / b.z);
-  return result;
-}
-api Vec3I operator/(Vec3I a, S32 b) {
-  Vec3I result = vec3i(a.x / b, a.y / b, a.z / b);
-  return result;
-}
-api Vec3I operator/(S32 a, Vec3I b) {
-  Vec3I result = vec3i(a / b.x, a / b.y, a / b.z);
-  return result;
-}
-api Vec3I &operator/=(Vec3I &a, Vec3I b) {
-  a = a / b;
-  return a;
-}
-api Vec3I &operator/=(Vec3I &a, S32 b) {
-  a = a / b;
-  return a;
-}
-api B32 operator!=(Vec3I a, Vec3I b) {
-  B32 result = (a.x != b.x) || (a.y != b.y) || (a.z != b.z);
-  return result;
-}
-api B32 operator==(Vec3I a, Vec3I b) {
-  B32 result = (a.x == b.x) && (a.y == b.y) && (a.z == b.z);
-  return result;
-}
-api Vec3I operator-(Vec3I a) {
-  Vec3I result = vec3i(-a.x, -a.y, -a.z);
-  return result;
-}
-api Vec3I clamp(Vec3I min, Vec3I val, Vec3I max) {
-  Vec3I result = vec3i(clamp(min.x, val.x, max.x), clamp(min.y, val.y, max.y), clamp(min.z, val.z, max.z));
-  return result;
-}
-api Vec3I clamp(S32 min, Vec3I val, S32 max) {
-  Vec3I result = vec3i(clamp(min, val.x, max), clamp(min, val.y, max), clamp(min, val.z, max));
-  return result;
-}
-api Vec3I clamp01(Vec3I val) {
-  Vec3I result = vec3i(clamp01(val.x), clamp01(val.y), clamp01(val.z));
-  return result;
-}
-api Vec4I v4i(S32 x, S32 y, S32 z, S32 w) {
-  Vec4I result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-api Vec4I v4i() { return v4i(0, 0, 0, 0); }
-api Vec4I operator+(Vec4I a, Vec4I b) {
-  Vec4I result = v4i(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
-  return result;
-}
-api Vec4I operator+(Vec4I a, S32 b) {
-  Vec4I result = v4i(a.x + b, a.y + b, a.z + b, a.w + b);
-  return result;
-}
-api Vec4I operator+(S32 a, Vec4I b) {
-  Vec4I result = v4i(a + b.x, a + b.y, a + b.z, a + b.w);
-  return result;
-}
-api Vec4I &operator+=(Vec4I &a, Vec4I b) {
-  a = a + b;
-  return a;
-}
-api Vec4I &operator+=(Vec4I &a, S32 b) {
-  a = a + b;
-  return a;
-}
-api Vec4I operator-(Vec4I a, Vec4I b) {
-  Vec4I result = v4i(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
-  return result;
-}
-api Vec4I operator-(Vec4I a, S32 b) {
-  Vec4I result = v4i(a.x - b, a.y - b, a.z - b, a.w - b);
-  return result;
-}
-api Vec4I operator-(S32 a, Vec4I b) {
-  Vec4I result = v4i(a - b.x, a - b.y, a - b.z, a - b.w);
-  return result;
-}
-api Vec4I &operator-=(Vec4I &a, Vec4I b) {
-  a = a - b;
-  return a;
-}
-api Vec4I &operator-=(Vec4I &a, S32 b) {
-  a = a - b;
-  return a;
-}
-api Vec4I operator*(Vec4I a, Vec4I b) {
-  Vec4I result = v4i(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
-  return result;
-}
-api Vec4I operator*(Vec4I a, S32 b) {
-  Vec4I result = v4i(a.x * b, a.y * b, a.z * b, a.w * b);
-  return result;
-}
-api Vec4I operator*(S32 a, Vec4I b) {
-  Vec4I result = v4i(a * b.x, a * b.y, a * b.z, a * b.w);
-  return result;
-}
-api Vec4I &operator*=(Vec4I &a, Vec4I b) {
-  a = a * b;
-  return a;
-}
-api Vec4I &operator*=(Vec4I &a, S32 b) {
-  a = a * b;
-  return a;
-}
-api Vec4I operator/(Vec4I a, Vec4I b) {
-  Vec4I result = v4i(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
-  return result;
-}
-api Vec4I operator/(Vec4I a, S32 b) {
-  Vec4I result = v4i(a.x / b, a.y / b, a.z / b, a.w / b);
-  return result;
-}
-api Vec4I operator/(S32 a, Vec4I b) {
-  Vec4I result = v4i(a / b.x, a / b.y, a / b.z, a / b.w);
-  return result;
-}
-api Vec4I &operator/=(Vec4I &a, Vec4I b) {
-  a = a / b;
-  return a;
-}
-api Vec4I &operator/=(Vec4I &a, S32 b) {
-  a = a / b;
-  return a;
-}
-api B32 operator!=(Vec4I a, Vec4I b) {
-  B32 result = (a.x != b.x) || (a.y != b.y) || (a.z != b.z) || (a.w != b.w);
-  return result;
-}
-api B32 operator==(Vec4I a, Vec4I b) {
-  B32 result = (a.x == b.x) && (a.y == b.y) && (a.z == b.z) && (a.w == b.w);
-  return result;
-}
-api Vec4I operator-(Vec4I a) {
-  Vec4I result = v4i(-a.x, -a.y, -a.z, -a.w);
-  return result;
-}
-api Vec4I clamp(Vec4I min, Vec4I val, Vec4I max) {
-  Vec4I result = v4i(clamp(min.x, val.x, max.x), clamp(min.y, val.y, max.y), clamp(min.z, val.z, max.z),
-                     clamp(min.w, val.w, max.w));
-  return result;
-}
-api Vec4I clamp(S32 min, Vec4I val, S32 max) {
-  Vec4I result =
-    v4i(clamp(min, val.x, max), clamp(min, val.y, max), clamp(min, val.z, max), clamp(min, val.w, max));
-  return result;
-}
-api Vec4I clamp01(Vec4I val) {
-  Vec4I result = v4i(clamp01(val.x), clamp01(val.y), clamp01(val.z), clamp01(val.w));
-  return result;
-}
-api Rect2 rect2(F32 min_x, F32 min_y, F32 max_x, F32 max_y) {
-  Rect2 result;
-  result.min_x = min_x;
-  result.min_y = min_y;
-  result.max_x = max_x;
-  result.max_y = max_y;
-  return result;
-}
-api Rect2 rect2() { return rect2(0, 0, 0, 0); }
-api Rect2 operator+(Rect2 a, Rect2 b) {
-  Rect2 result = rect2(a.min_x + b.min_x, a.min_y + b.min_y, a.max_x + b.max_x, a.max_y + b.max_y);
-  return result;
-}
-api Rect2 operator+(Rect2 a, F32 b) {
-  Rect2 result = rect2(a.min_x + b, a.min_y + b, a.max_x + b, a.max_y + b);
-  return result;
-}
-api Rect2 operator+(F32 a, Rect2 b) {
-  Rect2 result = rect2(a + b.min_x, a + b.min_y, a + b.max_x, a + b.max_y);
-  return result;
-}
-api Rect2 &operator+=(Rect2 &a, Rect2 b) {
-  a = a + b;
-  return a;
-}
-api Rect2 &operator+=(Rect2 &a, F32 b) {
-  a = a + b;
-  return a;
-}
-api Rect2 operator-(Rect2 a, Rect2 b) {
-  Rect2 result = rect2(a.min_x - b.min_x, a.min_y - b.min_y, a.max_x - b.max_x, a.max_y - b.max_y);
-  return result;
-}
-api Rect2 operator-(Rect2 a, F32 b) {
-  Rect2 result = rect2(a.min_x - b, a.min_y - b, a.max_x - b, a.max_y - b);
-  return result;
-}
-api Rect2 operator-(F32 a, Rect2 b) {
-  Rect2 result = rect2(a - b.min_x, a - b.min_y, a - b.max_x, a - b.max_y);
-  return result;
-}
-api Rect2 &operator-=(Rect2 &a, Rect2 b) {
-  a = a - b;
-  return a;
-}
-api Rect2 &operator-=(Rect2 &a, F32 b) {
-  a = a - b;
-  return a;
-}
-api Rect2 operator*(Rect2 a, Rect2 b) {
-  Rect2 result = rect2(a.min_x * b.min_x, a.min_y * b.min_y, a.max_x * b.max_x, a.max_y * b.max_y);
-  return result;
-}
-api Rect2 operator*(Rect2 a, F32 b) {
-  Rect2 result = rect2(a.min_x * b, a.min_y * b, a.max_x * b, a.max_y * b);
-  return result;
-}
-api Rect2 operator*(F32 a, Rect2 b) {
-  Rect2 result = rect2(a * b.min_x, a * b.min_y, a * b.max_x, a * b.max_y);
-  return result;
-}
-api Rect2 &operator*=(Rect2 &a, Rect2 b) {
-  a = a * b;
-  return a;
-}
-api Rect2 &operator*=(Rect2 &a, F32 b) {
-  a = a * b;
-  return a;
-}
-api Rect2 operator/(Rect2 a, Rect2 b) {
-  Rect2 result = rect2(a.min_x / b.min_x, a.min_y / b.min_y, a.max_x / b.max_x, a.max_y / b.max_y);
-  return result;
-}
-api Rect2 operator/(Rect2 a, F32 b) {
-  Rect2 result = rect2(a.min_x / b, a.min_y / b, a.max_x / b, a.max_y / b);
-  return result;
-}
-api Rect2 operator/(F32 a, Rect2 b) {
-  Rect2 result = rect2(a / b.min_x, a / b.min_y, a / b.max_x, a / b.max_y);
-  return result;
-}
-api Rect2 &operator/=(Rect2 &a, Rect2 b) {
-  a = a / b;
-  return a;
-}
-api Rect2 &operator/=(Rect2 &a, F32 b) {
-  a = a / b;
-  return a;
-}
-api B32 operator!=(Rect2 a, Rect2 b) {
-  B32 result = (a.min_x != b.min_x) || (a.min_y != b.min_y) || (a.max_x != b.max_x) || (a.max_y != b.max_y);
-  return result;
-}
-api B32 operator==(Rect2 a, Rect2 b) {
-  B32 result = (a.min_x == b.min_x) && (a.min_y == b.min_y) && (a.max_x == b.max_x) && (a.max_y == b.max_y);
-  return result;
-}
-api Rect2 operator-(Rect2 a) {
-  Rect2 result = rect2(-a.min_x, -a.min_y, -a.max_x, -a.max_y);
-  return result;
-}
-api Rect2 clamp(Rect2 min, Rect2 val, Rect2 max) {
-  Rect2 result = rect2(clamp(min.min_x, val.min_x, max.min_x), clamp(min.min_y, val.min_y, max.min_y),
-                       clamp(min.max_x, val.max_x, max.max_x), clamp(min.max_y, val.max_y, max.max_y));
-  return result;
-}
-api Rect2 clamp(F32 min, Rect2 val, F32 max) {
-  Rect2 result = rect2(clamp(min, val.min_x, max), clamp(min, val.min_y, max), clamp(min, val.max_x, max),
-                       clamp(min, val.max_y, max));
-  return result;
-}
-api Rect2 clamp01(Rect2 val) {
-  Rect2 result = rect2(clamp01(val.min_x), clamp01(val.min_y), clamp01(val.max_x), clamp01(val.max_y));
-  return result;
-}
-api Rect2I rect2i(S32 min_x, S32 min_y, S32 max_x, S32 max_y) {
-  Rect2I result;
-  result.min_x = min_x;
-  result.min_y = min_y;
-  result.max_x = max_x;
-  result.max_y = max_y;
-  return result;
-}
-api Rect2I rect2i() { return rect2i(0, 0, 0, 0); }
-api Rect2I operator+(Rect2I a, Rect2I b) {
-  Rect2I result = rect2i(a.min_x + b.min_x, a.min_y + b.min_y, a.max_x + b.max_x, a.max_y + b.max_y);
-  return result;
-}
-api Rect2I operator+(Rect2I a, S32 b) {
-  Rect2I result = rect2i(a.min_x + b, a.min_y + b, a.max_x + b, a.max_y + b);
-  return result;
-}
-api Rect2I operator+(S32 a, Rect2I b) {
-  Rect2I result = rect2i(a + b.min_x, a + b.min_y, a + b.max_x, a + b.max_y);
-  return result;
-}
-api Rect2I &operator+=(Rect2I &a, Rect2I b) {
-  a = a + b;
-  return a;
-}
-api Rect2I &operator+=(Rect2I &a, S32 b) {
-  a = a + b;
-  return a;
-}
-api Rect2I operator-(Rect2I a, Rect2I b) {
-  Rect2I result = rect2i(a.min_x - b.min_x, a.min_y - b.min_y, a.max_x - b.max_x, a.max_y - b.max_y);
-  return result;
-}
-api Rect2I operator-(Rect2I a, S32 b) {
-  Rect2I result = rect2i(a.min_x - b, a.min_y - b, a.max_x - b, a.max_y - b);
-  return result;
-}
-api Rect2I operator-(S32 a, Rect2I b) {
-  Rect2I result = rect2i(a - b.min_x, a - b.min_y, a - b.max_x, a - b.max_y);
-  return result;
-}
-api Rect2I &operator-=(Rect2I &a, Rect2I b) {
-  a = a - b;
-  return a;
-}
-api Rect2I &operator-=(Rect2I &a, S32 b) {
-  a = a - b;
-  return a;
-}
-api Rect2I operator*(Rect2I a, Rect2I b) {
-  Rect2I result = rect2i(a.min_x * b.min_x, a.min_y * b.min_y, a.max_x * b.max_x, a.max_y * b.max_y);
-  return result;
-}
-api Rect2I operator*(Rect2I a, S32 b) {
-  Rect2I result = rect2i(a.min_x * b, a.min_y * b, a.max_x * b, a.max_y * b);
-  return result;
-}
-api Rect2I operator*(S32 a, Rect2I b) {
-  Rect2I result = rect2i(a * b.min_x, a * b.min_y, a * b.max_x, a * b.max_y);
-  return result;
-}
-api Rect2I &operator*=(Rect2I &a, Rect2I b) {
-  a = a * b;
-  return a;
-}
-api Rect2I &operator*=(Rect2I &a, S32 b) {
-  a = a * b;
-  return a;
-}
-api Rect2I operator/(Rect2I a, Rect2I b) {
-  Rect2I result = rect2i(a.min_x / b.min_x, a.min_y / b.min_y, a.max_x / b.max_x, a.max_y / b.max_y);
-  return result;
-}
-api Rect2I operator/(Rect2I a, S32 b) {
-  Rect2I result = rect2i(a.min_x / b, a.min_y / b, a.max_x / b, a.max_y / b);
-  return result;
-}
-api Rect2I operator/(S32 a, Rect2I b) {
-  Rect2I result = rect2i(a / b.min_x, a / b.min_y, a / b.max_x, a / b.max_y);
-  return result;
-}
-api Rect2I &operator/=(Rect2I &a, Rect2I b) {
-  a = a / b;
-  return a;
-}
-api Rect2I &operator/=(Rect2I &a, S32 b) {
-  a = a / b;
-  return a;
-}
-api B32 operator!=(Rect2I a, Rect2I b) {
-  B32 result = (a.min_x != b.min_x) || (a.min_y != b.min_y) || (a.max_x != b.max_x) || (a.max_y != b.max_y);
-  return result;
-}
-api B32 operator==(Rect2I a, Rect2I b) {
-  B32 result = (a.min_x == b.min_x) && (a.min_y == b.min_y) && (a.max_x == b.max_x) && (a.max_y == b.max_y);
-  return result;
-}
-api Rect2I operator-(Rect2I a) {
-  Rect2I result = rect2i(-a.min_x, -a.min_y, -a.max_x, -a.max_y);
-  return result;
-}
-api Rect2I clamp(Rect2I min, Rect2I val, Rect2I max) {
-  Rect2I result = rect2i(clamp(min.min_x, val.min_x, max.min_x), clamp(min.min_y, val.min_y, max.min_y),
-                         clamp(min.max_x, val.max_x, max.max_x), clamp(min.max_y, val.max_y, max.max_y));
-  return result;
-}
-api Rect2I clamp(S32 min, Rect2I val, S32 max) {
-  Rect2I result = rect2i(clamp(min, val.min_x, max), clamp(min, val.min_y, max), clamp(min, val.max_x, max),
-                         clamp(min, val.max_y, max));
-  return result;
-}
-api Rect2I clamp01(Rect2I val) {
-  Rect2I result = rect2i(clamp01(val.min_x), clamp01(val.min_y), clamp01(val.max_x), clamp01(val.max_y));
-  return result;
-}
-api Vec2 cast_v2(Vec2I a) {
-  Vec2 result = vec2((F32)(a.x), (F32)(a.y));
-  return result;
-}
-api Vec2I cast_v2i(Vec2 a) {
-  Vec2I result = vec2i((S32)(a.x), (S32)(a.y));
-  return result;
-}
-api Vec2I round_cast_v2i(Vec2 a) {
-  Vec2I result = vec2i((S32)round(a.x), (S32)round(a.y));
-  return result;
-}
-api Vec2I ceil_cast_v2i(Vec2 a) {
-  Vec2I result = vec2i((S32)ceil(a.x), (S32)ceil(a.y));
-  return result;
-}
-api Vec2I floor_cast_v2i(Vec2 a) {
-  Vec2I result = vec2i((S32)floor(a.x), (S32)floor(a.y));
-  return result;
-}
-api Vec3 cast_v3(Vec3I a) {
-  Vec3 result = vec3((F32)(a.x), (F32)(a.y), (F32)(a.z));
-  return result;
-}
-api Vec3I cast_v3i(Vec3 a) {
-  Vec3I result = vec3i((S32)(a.x), (S32)(a.y), (S32)(a.z));
-  return result;
-}
-api Vec3I round_cast_v3i(Vec3 a) {
-  Vec3I result = vec3i((S32)round(a.x), (S32)round(a.y), (S32)round(a.z));
-  return result;
-}
-api Vec3I ceil_cast_v3i(Vec3 a) {
-  Vec3I result = vec3i((S32)ceil(a.x), (S32)ceil(a.y), (S32)ceil(a.z));
-  return result;
-}
-api Vec3I floor_cast_v3i(Vec3 a) {
-  Vec3I result = vec3i((S32)floor(a.x), (S32)floor(a.y), (S32)floor(a.z));
-  return result;
-}
-api Vec4 cast_v4(Vec4I a) {
-  Vec4 result = vec4((F32)(a.x), (F32)(a.y), (F32)(a.z), (F32)(a.w));
-  return result;
-}
-api Vec4I cast_v4i(Vec4 a) {
-  Vec4I result = v4i((S32)(a.x), (S32)(a.y), (S32)(a.z), (S32)(a.w));
-  return result;
-}
-api Vec4I round_cast_v4i(Vec4 a) {
-  Vec4I result = v4i((S32)round(a.x), (S32)round(a.y), (S32)round(a.z), (S32)round(a.w));
-  return result;
-}
-api Vec4I ceil_cast_v4i(Vec4 a) {
-  Vec4I result = v4i((S32)ceil(a.x), (S32)ceil(a.y), (S32)ceil(a.z), (S32)ceil(a.w));
-  return result;
-}
-api Vec4I floor_cast_v4i(Vec4 a) {
-  Vec4I result = v4i((S32)floor(a.x), (S32)floor(a.y), (S32)floor(a.z), (S32)floor(a.w));
-  return result;
-}
-api Rect2 cast_rect2(Rect2I a) {
-  Rect2 result = rect2((F32)(a.min_x), (F32)(a.min_y), (F32)(a.max_x), (F32)(a.max_y));
-  return result;
-}
-api Rect2I cast_rect2i(Rect2 a) {
-  Rect2I result = rect2i((S32)(a.min_x), (S32)(a.min_y), (S32)(a.max_x), (S32)(a.max_y));
-  return result;
-}
-api Rect2I round_cast_rect2i(Rect2 a) {
-  Rect2I result = rect2i((S32)round(a.min_x), (S32)round(a.min_y), (S32)round(a.max_x), (S32)round(a.max_y));
-  return result;
-}
-api Rect2I ceil_cast_rect2i(Rect2 a) {
-  Rect2I result = rect2i((S32)ceil(a.min_x), (S32)ceil(a.min_y), (S32)ceil(a.max_x), (S32)ceil(a.max_y));
-  return result;
-}
-api Rect2I floor_cast_rect2i(Rect2 a) {
-  Rect2I result = rect2i((S32)floor(a.min_x), (S32)floor(a.min_y), (S32)floor(a.max_x), (S32)floor(a.max_y));
-  return result;
-}
-api Rect2I rect2i(Vec2I a, Vec2I b) {
-  Rect2I result = rect2i(a.p[0], a.p[1], b.p[0], b.p[1]);
-  return result;
-}
-api Rect2I rect2i(S32 a, Vec3I b) {
-  Rect2I result = rect2i(a, b.p[0], b.p[1], b.p[2]);
-  return result;
-}
-api Rect2I rect2i(Vec3I a, S32 b) {
-  Rect2I result = rect2i(a.p[0], a.p[1], a.p[2], b);
-  return result;
-}
-api Rect2I rect2i(Vec2I a, S32 b, S32 c) {
-  Rect2I result = rect2i(a.p[0], a.p[1], b, c);
-  return result;
-}
-api Rect2I rect2i(S32 a, S32 b, Vec2I c) {
-  Rect2I result = rect2i(a, b, c.p[0], c.p[1]);
-  return result;
-}
-api Vec4I v4i(Vec2I a, Vec2I b) {
-  Vec4I result = v4i(a.p[0], a.p[1], b.p[0], b.p[1]);
-  return result;
-}
-api Vec4I v4i(S32 a, Vec3I b) {
-  Vec4I result = v4i(a, b.p[0], b.p[1], b.p[2]);
-  return result;
-}
-api Vec4I v4i(Vec3I a, S32 b) {
-  Vec4I result = v4i(a.p[0], a.p[1], a.p[2], b);
-  return result;
-}
-api Vec4I v4i(Vec2I a, S32 b, S32 c) {
-  Vec4I result = v4i(a.p[0], a.p[1], b, c);
-  return result;
-}
-api Vec4I v4i(S32 a, S32 b, Vec2I c) {
-  Vec4I result = v4i(a, b, c.p[0], c.p[1]);
-  return result;
-}
-api Rect2 rect2(Vec2 a, Vec2 b) {
-  Rect2 result = rect2(a.p[0], a.p[1], b.p[0], b.p[1]);
-  return result;
-}
-api Rect2 rect2(F32 a, Vec3 b) {
-  Rect2 result = rect2(a, b.p[0], b.p[1], b.p[2]);
-  return result;
-}
-api Rect2 rect2(Vec3 a, F32 b) {
-  Rect2 result = rect2(a.p[0], a.p[1], a.p[2], b);
-  return result;
-}
-api Rect2 rect2(Vec2 a, F32 b, F32 c) {
-  Rect2 result = rect2(a.p[0], a.p[1], b, c);
-  return result;
-}
-api Rect2 rect2(F32 a, F32 b, Vec2 c) {
-  Rect2 result = rect2(a, b, c.p[0], c.p[1]);
-  return result;
-}
-api Vec4 vec4(Vec2 a, Vec2 b) {
-  Vec4 result = vec4(a.p[0], a.p[1], b.p[0], b.p[1]);
-  return result;
-}
-api Vec4 vec4(F32 a, Vec3 b) {
-  Vec4 result = vec4(a, b.p[0], b.p[1], b.p[2]);
-  return result;
-}
-api Vec4 vec4(Vec3 a, F32 b) {
-  Vec4 result = vec4(a.p[0], a.p[1], a.p[2], b);
-  return result;
-}
-api Vec4 vec4(Vec2 a, F32 b, F32 c) {
-  Vec4 result = vec4(a.p[0], a.p[1], b, c);
-  return result;
-}
-api Vec4 vec4(F32 a, F32 b, Vec2 c) {
-  Vec4 result = vec4(a, b, c.p[0], c.p[1]);
-  return result;
-}
-api Rect2 rect2_min_size(Vec2 a, Vec2 b) {
-  Rect2 result = rect2(a.p[0], a.p[1], b.p[0], b.p[1]);
-  result.max += result.min;
-  return result;
-}
-api Rect2 rect2_min_size(F32 a, Vec3 b) {
-  Rect2 result = rect2(a, b.p[0], b.p[1], b.p[2]);
-  result.max += result.min;
-  return result;
-}
-api Rect2 rect2_min_size(Vec3 a, F32 b) {
-  Rect2 result = rect2(a.p[0], a.p[1], a.p[2], b);
-  result.max += result.min;
-  return result;
-}
-api Rect2 rect2_min_size(Vec2 a, F32 b, F32 c) {
-  Rect2 result = rect2(a.p[0], a.p[1], b, c);
-  result.max += result.min;
-  return result;
-}
-api Rect2 rect2_min_size(F32 a, F32 b, Vec2 c) {
-  Rect2 result = rect2(a, b, c.p[0], c.p[1]);
-  result.max += result.min;
-  return result;
-}
-api Rect2I rect2i_min_size(Vec2I a, Vec2I b) {
-  Rect2I result = rect2i(a.p[0], a.p[1], b.p[0], b.p[1]);
-  result.max += result.min;
-  return result;
-}
-api Rect2I rect2i_min_size(S32 a, Vec3I b) {
-  Rect2I result = rect2i(a, b.p[0], b.p[1], b.p[2]);
-  result.max += result.min;
-  return result;
-}
-api Rect2I rect2i_min_size(Vec3I a, S32 b) {
-  Rect2I result = rect2i(a.p[0], a.p[1], a.p[2], b);
-  result.max += result.min;
-  return result;
-}
-api Rect2I rect2i_min_size(Vec2I a, S32 b, S32 c) {
-  Rect2I result = rect2i(a.p[0], a.p[1], b, c);
-  result.max += result.min;
-  return result;
-}
-api Rect2I rect2i_min_size(S32 a, S32 b, Vec2I c) {
-  Rect2I result = rect2i(a, b, c.p[0], c.p[1]);
-  result.max += result.min;
-  return result;
-}
-api Rect2 rect2_center_half_dim(Vec2 a, Vec2 b) {
-  Rect2 result = rect2(a.p[0], a.p[1], b.p[0], b.p[1]);
-  Vec2 center = result.min;
-  result.min -= result.max;
-  result.max += center;
-  return result;
-}
-api Rect2 rect2_center_half_dim(F32 a, Vec3 b) {
-  Rect2 result = rect2(a, b.p[0], b.p[1], b.p[2]);
-  Vec2 center = result.min;
-  result.min -= result.max;
-  result.max += center;
-  return result;
-}
-api Rect2 rect2_center_half_dim(Vec3 a, F32 b) {
-  Rect2 result = rect2(a.p[0], a.p[1], a.p[2], b);
-  Vec2 center = result.min;
-  result.min -= result.max;
-  result.max += center;
-  return result;
-}
-api Rect2 rect2_center_half_dim(Vec2 a, F32 b, F32 c) {
-  Rect2 result = rect2(a.p[0], a.p[1], b, c);
-  Vec2 center = result.min;
-  result.min -= result.max;
-  result.max += center;
-  return result;
-}
-api Rect2 rect2_center_half_dim(F32 a, F32 b, Vec2 c) {
-  Rect2 result = rect2(a, b, c.p[0], c.p[1]);
-  Vec2 center = result.min;
-  result.min -= result.max;
-  result.max += center;
-  return result;
-}
-api Rect2I rect2i_center_half_dim(Vec2I a, Vec2I b) {
-  Rect2I result = rect2i(a.p[0], a.p[1], b.p[0], b.p[1]);
-  Vec2I center = result.min;
-  result.min -= result.max;
-  result.max += center;
-  return result;
-}
-api Rect2I rect2i_center_half_dim(S32 a, Vec3I b) {
-  Rect2I result = rect2i(a, b.p[0], b.p[1], b.p[2]);
-  Vec2I center = result.min;
-  result.min -= result.max;
-  result.max += center;
-  return result;
-}
-api Rect2I rect2i_center_half_dim(Vec3I a, S32 b) {
-  Rect2I result = rect2i(a.p[0], a.p[1], a.p[2], b);
-  Vec2I center = result.min;
-  result.min -= result.max;
-  result.max += center;
-  return result;
-}
-api Rect2I rect2i_center_half_dim(Vec2I a, S32 b, S32 c) {
-  Rect2I result = rect2i(a.p[0], a.p[1], b, c);
-  Vec2I center = result.min;
-  result.min -= result.max;
-  result.max += center;
-  return result;
-}
-api Rect2I rect2i_center_half_dim(S32 a, S32 b, Vec2I c) {
-  Rect2I result = rect2i(a, b, c.p[0], c.p[1]);
-  Vec2I center = result.min;
-  result.min -= result.max;
-  result.max += center;
-  return result;
-}
-api Rect2 rect2_min_size(F32 a, F32 b, F32 c, F32 d) {
-  Rect2 result = rect2(a, b, c, d);
-  result.max += result.min;
-  return result;
-}
-api Rect2I rect2i_min_size(S32 a, S32 b, S32 c, S32 d) {
-  Rect2I result = rect2i(a, b, c, d);
-  result.max += result.min;
-  return result;
-}
-api Rect2 rect2_center_half_dim(F32 a, F32 b, F32 c, F32 d) {
-  Rect2 result = rect2(a, b, c, d);
-  Vec2 center = result.min;
-  result.min -= result.max;
-  result.max += center;
-  return result;
-}
-api Rect2I rect2i_center_half_dim(S32 a, S32 b, S32 c, S32 d) {
-  Rect2I result = rect2i(a, b, c, d);
-  Vec2I center = result.min;
-  result.min -= result.max;
-  result.max += center;
-  return result;
-}
-api Vec3 vec3(F32 a, Vec2 b) {
-  Vec3 result = vec3(a, b.p[0], b.p[1]);
-  return result;
-}
-api Vec3 vec3(Vec2 a, F32 b) {
-  Vec3 result = vec3(a.p[0], a.p[1], b);
-  return result;
-}
-api Vec3I vec3i(S32 a, Vec2I b) {
-  Vec3I result = vec3i(a, b.p[0], b.p[1]);
-  return result;
-}
-api Vec3I vec3i(Vec2I a, S32 b) {
-  Vec3I result = vec3i(a.p[0], a.p[1], b);
-  return result;
-}
-
-api Rect2I intersect(Rect2I a, Rect2I clip) {
-  Rect2I result;
-  result.min.x = max(a.min.x, clip.min.x);
-  result.min.y = max(a.min.y, clip.min.y);
-  result.max.x = min(a.max.x, clip.max.x);
-  result.max.y = min(a.max.y, clip.max.y);
-  return result;
-}
-
-api B32 has_area(Rect2I a) {
-  B32 result = (a.max_x - a.min_x > 0) && (a.max_y - a.min_y > 0);
-  return result;
-}
-
-api Rect2 intersect(Rect2 a, Rect2 clip) {
-  Rect2 result;
-  result.min.x = max(a.min.x, clip.min.x);
-  result.min.y = max(a.min.y, clip.min.y);
-  result.max.x = min(a.max.x, clip.max.x);
-  result.max.y = min(a.max.y, clip.max.y);
-  return result;
-}
-
-api B32 has_area(Rect2 a) {
-  B32 result = (a.max_x - a.min_x > 0) && (a.max_y - a.min_y > 0);
-  return result;
-}
-
-api Vec2 perp(Vec2 a) {
-  Vec2 result = vec2(-a.y, a.x);
-  return result;
-}
-
-api Vec4 vec4argb(U32 v) {
-  U8 a = (v >> 24) & 0x000000ff;
-  U8 r = (v >> 16) & 0x000000ff;
-  U8 g = (v >> 8) & 0x000000ff;
-  U8 b = (v >> 0) & 0x000000ff;
-  Vec4 result = vec4((F32)r / 255.f, (F32)g / 255.f, (F32)b / 255.f, (F32)a / 255.f);
-  return result;
-}
-
-api Vec4 vec4abgr(U32 c) {
-  float a = ((c & 0xff000000) >> 24) / 255.f;
-  float b = ((c & 0x00ff0000) >> 16) / 255.f;
-  float g = ((c & 0x0000ff00) >> 8) / 255.f;
-  float r = ((c & 0x000000ff) >> 0) / 255.f;
-  Vec4 result = vec4(r, g, b, a);
-  return result;
-}
-
-api U32 vec4_to_u32argb(Vec4 c) {
-  U32 result = (U32)((U8)(c.a * 255.f) << 24u | (U8)(c.r * 255.f) << 16u | (U8)(c.g * 255.f) << 8u |
-                     (U8)(c.b * 255.f) << 0u);
-  return result;
-}
-
-api U32 vec4_to_u32abgr(Vec4 color) {
-  U8 red = (U8)(color.r * 255);
-  U8 green = (U8)(color.g * 255);
-  U8 blue = (U8)(color.b * 255);
-  U8 alpha = (U8)(color.a * 255);
-  U32 result = (U32)(alpha << 24 | blue << 16 | green << 8 | red << 0);
-  return result;
-}
-
-api Mat4 operator*(Mat4 a, Mat4 b) {
-  Mat4 result;
-  for (int y = 0; y < 4; y++) {
-    for (int x = 0; x < 4; x++) {
-      result.p[y][x] =
-        a.p[y][0] * b.p[0][x] + a.p[y][1] * b.p[1][x] + a.p[y][2] * b.p[2][x] + a.p[y][3] * b.p[3][x];
-    }
-  }
-  return result;
-}
-
-api Vec4 operator*(Mat4 a, Vec4 b) {
-  Vec4 result;
-  for (int y = 0; y < 4; y++) {
-    result.p[y] = a.p[y][0] * b.p[0] + a.p[y][1] * b.p[1] + a.p[y][2] * b.p[2] + a.p[y][3] * b.p[3];
-  }
-  return result;
-}
-
-api Vec3 operator*(Mat4 a, Vec3 b) {
-  Vec4 result;
-  for (int y = 0; y < 4; y++)
-    result.p[y] = a.p[y][0] * b.p[0] + a.p[y][1] * b.p[1] + a.p[y][2] * b.p[2] + a.p[y][3] * 1;
-  return result.xyz;
-}
-
-api Vec3 cross(Vec3 a, Vec3 b) {
-  Vec3 result;
-  result.x = a.y * b.z - a.z * b.y;
-  result.y = a.z * b.x - a.x * b.z;
-  result.z = a.x * b.y - a.y * b.x;
-  return result;
-}
-
-api Vec2 normalize(Vec2 a) {
-  Vec2 result = {};
-  F32 len = length(a);
-  if (len != 0.f) {
-    F32 inv_len = 1.0f / len;
-    result.x = a.x * inv_len;
-    result.y = a.y * inv_len;
-  }
-  return result;
-}
-
-api Vec3 normalize(Vec3 a) {
-  Vec3 result = {};
-  F32 len = length(a);
-  if (len != 0.f) {
-    F32 inv_len = 1.0f / len;
-    result.x = a.x * inv_len;
-    result.y = a.y * inv_len;
-    result.z = a.z * inv_len;
-  }
-  return result;
-}
-
-api Vec4 normalize(Vec4 a) {
-  Vec4 result = {};
-  F32 len = length(a);
-  if (len != 0.f) {
-    F32 inv_len = 1.0f / len;
-    result.x = a.x * inv_len;
-    result.y = a.y * inv_len;
-    result.z = a.z * inv_len;
-    result.w = a.w * inv_len;
-  }
-  return result;
-}
-
-CORE_Static
-Mat4 mat4_identity() {
-  Mat4 result = {};
-  result.p[0][0] = 1;
-  result.p[1][1] = 1;
-  result.p[2][2] = 1;
-  result.p[3][3] = 1;
-  return result;
-}
-
-CORE_Static
-Mat4 mat4_scale(Vec3 a) {
-  Mat4 result = {};
-  result.p[0][0] = a.x;
-  result.p[1][1] = a.y;
-  result.p[2][2] = a.z;
-  result.p[3][3] = 1;
-  return result;
-}
-
-CORE_Static
-Mat4 mat4_translation(Vec3 a) {
-  return {
-    1, 0, 0, a.x,
-    0, 1, 0, a.y,
-    0, 0, 1, a.z,
-    0, 0, 0, 1
-  };
-}
-
-CORE_Static
-Mat4 mat4_rotation_z(float rotation) {
-  float s = sinf(rotation);
-  float c = cosf(rotation);
-  Mat4 result = {
-    c, s, 0, 0,
-    -s,  c, 0, 0,
-    0,  0, 1, 0,
-    0,  0, 0, 1,
-  };
-  return result;
-}
-
-CORE_Static
-Mat4 mat4_rotation_y(float rotation) {
-  float s = sinf(rotation);
-  float c = cosf(rotation);
-  Mat4 result = {
-    c, 0, -s, 0,
-    0, 1,  0, 0,
-    s, 0,  c, 0,
-    0, 0,  0, 1,
-  };
-  return result;
-}
-
-CORE_Static
-Mat4 mat4_rotation_x(float rotation) {
-  float s = sinf(rotation);
-  float c = cosf(rotation);
-  Mat4 result = {
-    1,  0, 0, 0,
-    0,  c, s, 0,
-    0,  -s, c, 0,
-    0,  0, 0, 1,
-  };
-  return result;
-}
-
-constexpr F32 deg2rad = (PI32 / 180.f); // @Usage: degree * deg2rad = radians;
-constexpr F32 rad2deg = (180.f / PI32);
-CORE_Static
-Mat4 mat4_perspective(float fov, float window_x, float window_y, float znear, float zfar) {
-  float aspect_ratio = window_y / window_x;
-  float f = (1.f / tanf((fov/2.f)*deg2rad));
-  Mat4 result = {
-    aspect_ratio*f, 0, 0, 0,
-    0, f, 0, 0,
-    0, 0, (zfar)-(zfar-znear),(-zfar*znear)-(zfar - znear),
-    0,0,1,0
-  };
-  return result;
-}
-
-CORE_Static Mat4 mat4_look_at(Vec3 pos, Vec3 target, Vec3 up) {
-  Vec3 z = normalize(target - pos);
-  Vec3 x = normalize(cross(up, z));
-  Vec3 y = cross(z, x);
-  Mat4 result = {
-    x.x,x.y,x.z,-dot(x,pos),
-    y.x,y.y,y.z,-dot(y,pos),
-    z.x,z.y,z.z,-dot(z,pos),
-    0,0,0,       1,
-  };
-  return result;
-}
-
-CORE_Static
-Mat4 mat4_transpose(Mat4 a) {
-  Mat4 result = a;
-  result.p[0][1] = result.p[1][0];
-  result.p[0][2] = result.p[2][0];
-  result.p[0][3] = result.p[3][0];
-  result.p[2][1] = result.p[1][2];
-  result.p[3][1] = result.p[1][3];
-  result.p[3][2] = result.p[2][3];
-  return result;
-}
-
-CORE_Static
-Mat4 mat4_translate(Mat4 a, Vec3 translation) {
-  a.p[0][0] += translation.x;
-  a.p[0][1] += translation.y;
-  a.p[0][2] += translation.z;
-  return a;
-}
\ No newline at end of file
diff --git a/build.bat b/build.bat
index 6753be0..2d22d51 100644
--- a/build.bat
+++ b/build.bat
@@ -5,7 +5,7 @@ rem cl main.cpp -I.. user32.lib
 clang core_main.cpp -O0 -Wall -Wno-unused-function -fno-exceptions -fdiagnostics-absolute-paths -g -o main.exe -Wl,user32.lib
 rem ubuntu run clang core_main.cpp -O0 -Wall -Wno-unused-function -fno-exceptions -fdiagnostics-absolute-paths -g -o core.out
 
-main.exe -testing
+rem main.exe -testing
 
 rem echo Building arms race
 rem call examples/arms_race/build_arms_race.bat
diff --git a/c3_big_int.h b/c3_big_int.h
index 3682101..3f5ff3a 100644
--- a/c3_big_int.h
+++ b/c3_big_int.h
@@ -1,13 +1,4 @@
 struct Token;
-struct BigInt
-{
-  unsigned digit_count;
-  bool is_negative;
-  union {
-    uint64_t digit;
-    uint64_t *digits;
-  };
-};
 
 #include <inttypes.h>
 enum CmpRes
diff --git a/core_ast.cpp b/core_ast.cpp
index 51cc2aa..d72fcc8 100644
--- a/core_ast.cpp
+++ b/core_ast.cpp
@@ -1,332 +1,5 @@
 
-//-----------------------------------------------------------------------------
-// AST
-//-----------------------------------------------------------------------------
-enum Ast_Kind: U32{
-  AST_NONE,
 
-  AST_NAMESPACE,
-
-  AST_MODULE,
-  AST_FILE,
-  AST_SCOPE,
-  AST_VALUE,
-  AST_CAST,
-  AST_IDENT,
-  AST_INDEX,
-  AST_UNARY,
-  AST_BINARY,
-  AST_CALL_ITEM,
-  AST_CALL,
-
-  AST_CONSTANT_ASSERT,
-  AST_RUNTIME_ASSERT,
-  AST_SIZE_OF,
-  AST_LENGTH_OF,
-  AST_ALIGN_OF,
-  AST_TYPE_OF,
-
-  AST_SWITCH,
-  AST_SWITCH_CASE,
-  AST_VAR_UNPACK,
-  AST_BREAK,
-  AST_COMPOUND,
-  AST_TYPE,
-  AST_VAR,
-  AST_CONST,
-  AST_POINTER,
-  AST_ARRAY,
-  AST_FOR,
-  AST_IF,
-  AST_IF_NODE,
-  AST_RETURN,
-  AST_BLOCK,
-  AST_PASS,
-  AST_LAMBDA,
-  AST_LAMBDA_EXPR,
-  AST_LAMBDA_ARG,
-  AST_ENUM,
-  AST_ENUM_MEMBER,
-  AST_STRUCT,
-};
-
-typedef U32 Ast_Flag;
-enum{
-  AST_EXPR              = bit_flag(1),
-  AST_STMT              = bit_flag(2),
-  AST_STRICT            = bit_flag(3),
-  AST_AGGREGATE         = bit_flag(4),
-  AST_AGGREGATE_CHILD   = bit_flag(5),
-  AST_ATOM              = bit_flag(7),
-  AST_FOREIGN           = bit_flag(8),
-  AST_DECL              = bit_flag(9),
-  AST_GLOBAL            = bit_flag(10),
-  AST_FLAG              = bit_flag(11),
-  AST_VAR_IS_CONST      = bit_flag(12),
-  AST_OPERATOR_OVERLOAD = bit_flag(13),
-  AST_IS_LVALUE         = bit_flag(14),
-};
-
-struct Ast{
-  U64 di; // Debug id, shouldn't ever be used in the program
-  Token *pos;
-
-  Ast_Kind kind;
-  Ast_Scope *parent_scope;
-  Ast_Flag flags;
-};
-
-struct Ast_Type;
-struct Ast_Expr:Ast{
-  Ast_Type *resolved_type;
-  Ast_Decl *resolved_operator_overload;
-  union{
-    Ast_Type *index_original_type;
-    Ast_Type *cast_after_type;
-    Ast_Type *dot_access_step_resolution;
-  };
-};
-
-struct Ast_Atom: Ast_Expr{
-  // We have a field type here
-  // it has a different purpose from the
-  // resolved_type of Ast_Expr, it describes
-  // the inherent type of a value
-  //
-  // resolved_type is a solid type that
-  // can be use during code generation
-  // it cannot be untyped. (or at least thats the hope :)
-/*#import meta
-meta.inline_value_fields()
-*/
-union {
-    Value value;
-    struct {
-        Ast_Type *type;
-Ast_Decl *resolved_decl;
-union {
-    bool          bool_val;   
-    F64           f64_val;    
-    Intern_String intern_val; 
-    BigInt        big_int_val;
-    Ast_Type     *type_val;            
-};
-    };
-};
-/*END*/
-};
-
-typedef U32 Ast_Call_Item_Flag;
-enum{
-  CALL_INDEX   = bit_flag(1),
-  CALL_NAME    = bit_flag(2),
-  CALL_INCLUDED= bit_flag(4),
-};
-
-struct Ast_Call_Item: Ast_Expr{
-  Ast_Call_Item_Flag call_flags;
-  S32 resolved_index;
-  Ast_Expr *item;
-  union {
-    Ast_Atom *name;
-    Ast_Expr *index;
-  };
-  Intern_String resolved_name;
-};
-
-struct Ast_Lambda;
-struct Ast_Call: Ast_Expr{
-  union{
-    Ast_Expr *name;
-    Ast_Expr *typespec;
-  };
-  Array<Ast_Call_Item *> exprs;
-  Ast_Decl *resolved_decl;
-};
-
-struct Ast_Var_Unpack: Ast_Expr{
-  Array<Ast_Decl *> vars;
-  Ast_Expr *expr;
-};
-
-struct Ast_Unary: Ast_Expr{
-  Token_Kind op;
-  Ast_Expr *expr;
-  U64 padding[2]; // For folding constants into atoms
-};
-
-struct Ast_Index: Ast_Expr{
-  Ast_Expr *expr;
-  Ast_Expr *index;
-};
-
-struct Ast_Binary: Ast_Expr{
-  Token_Kind op;
-  Ast_Expr *left;
-  Ast_Expr *right;
-  Ast_Type *before_type;
-};
-
-struct Ast_Builtin: Ast_Expr{
-  Ast_Expr *expr;
-  Intern_String assert_message;
-  U64 padding[1]; // For folding constants into atoms
-};
-
-// Problem: We are parsing out of order, in the middle of parsing a function
-// we can jump down a different function, we cant therfore use global map.
-// Each scope needs to have it's checked locals list. To lookup syms we need to
-// look into global scope and to the locals list.
-//
-
-struct Ast_Return: Ast{
-  Ast_Type *resolved_type;
-  Array<Ast_Expr *> expr;
-};
-
-struct Ast_If_Node: Ast{
-  Ast_Expr  *expr ;
-  Ast_Scope *scope;
-  Ast_Binary*init;
-};
-
-struct Ast_If: Ast{
-  Array<Ast_If_Node *> ifs;
-};
-
-struct Ast_Pass: Ast{};
-struct Ast_Break: Ast{};
-
-struct Ast_For: Ast{
-  Ast_Expr *init;
-  Ast_Expr *cond;
-  Ast_Expr *iter;
-  Ast_Scope *scope;
-
-  Ast_Decl *array_traversal_var;
-  bool is_array_traversal;
-  bool is_also_slice_traversal;
-};
-
-struct Ast_Lambda : Ast_Expr {
-  Array<Ast_Decl *> args;
-  Array<Ast_Expr *> ret;
-  Ast_Scope        *scope;
-};
-
-struct Ast_Array: Ast_Expr{
-  Ast_Expr *base;
-  Ast_Expr *expr;
-  U64 padding[2];
-};
-
-struct Ast_Switch_Case: Ast{
-  Array<Ast_Expr *> labels;
-  Ast_Scope *scope;
-  B32 fallthrough;
-};
-
-struct Ast_Switch: Ast{
-  Ast_Expr *value;
-  Array<Ast_Switch_Case *> cases;
-  Ast_Scope *default_scope;
-};
-
-/*
-How does current declaration order resolver works:
-* First we put all the global declarations into the global scope (when parsing) all unresolved
-  * All the types are declared INCOMPLETE and RESOLVED
-* We descent the tree by resolving each of the named declarations, we resolve by their name
-  When we start resolving we set RESOLVING flag and when we complete RESOLVED flag
-  and put into ordered list
-* When we meet a symbol (named declaration) while descending the tree,
-  we resolve that symbol instead before resolving current declaration.
-* When we meet a declaration that requires size of a type - field access, var assignment,
-  we need to call "complete_type", it sets COMPLETING flag.
-  This call resolves all the dependencies of that type,
-  sets size of type and marks it as COMPLETE and puts into ordered list.
-  If it detects COMPLETING while
-  resolving, we got a circular dependency. That might happen when we have
-  that struct without pointer inside itself.
-
-*/
-
-struct Ast_Scope: Ast{
-  String debug_name; // Dont use
-  List<Ast_Scope *> implicit_imports;
-  List<Ast_Decl *>  decls;
-  Array<Ast      *> stmts;
-
-  U32 visit_id;
-  U32 scope_id;
-  Ast_Scope *file; // Self referential for file and module
-  Ast_Module *module;
-};
-
-enum Ast_Module_State{
-  MODULE_REGISTERED,
-  MODULE_PARSED,
-  MODULE_RESOLVED,
-};
-
-struct Ast_Module: Ast_Scope{
-  Ast_Module_State  state;
-  String            absolute_base_folder;
-  String            absolute_file_path;
-  List<Ast_File *>  all_loaded_files;
-};
-
-struct Ast_File: Ast_Scope{
-  String absolute_base_folder;
-  String absolute_file_path;
-  String filecontent;
-};
-
-enum Ast_Decl_State{
-  DECL_NOT_RESOLVED,
-  DECL_RESOLVED,
-  DECL_RESOLVED_TYPE,
-  DECL_RESOLVING,
-};
-
-struct Ast_Decl: Ast{
-  Ast_Decl_State state;
-  Intern_String name;
-  Intern_String unique_name; // For code generation, currently only present on lambdas
-
-  U64 operator_overload_arguments_hash;
-  Operator_Info *overload_op_info;
-
-  Ast_Scope *scope;
-  Ast_Expr *typespec;
-  union{
-    Ast_Expr *expr;
-    Ast_Lambda *lambda;
-  };
-
-/*#import meta
-meta.inline_value_fields()
-*/
-union {
-    Value value;
-    struct {
-        Ast_Type *type;
-Ast_Decl *resolved_decl;
-union {
-    bool          bool_val;   
-    F64           f64_val;    
-    Intern_String intern_val; 
-    BigInt        big_int_val;
-    Ast_Type     *type_val;            
-};
-    };
-};
-/*END*/
-};
-
-//-----------------------------------------------------------------------------
-// AST Constructors beginning with expressions
-//-----------------------------------------------------------------------------
 #define AST_NEW(T,ikind,ipos,iflags)                                   \
   Ast_##T *result = arena_push_type(pctx->perm, Ast_##T, AF_ZeroMemory);\
   result->flags   = iflags;                                            \
diff --git a/core_compiler.h b/core_compiler.h
index a3edf6e..8c6a8d5 100644
--- a/core_compiler.h
+++ b/core_compiler.h
@@ -1,127 +1,5 @@
-struct Ast_Scope;
-struct Ast_Decl;
-struct Ast_File_Namespace;
-struct Ast_File;
-struct Ast_Module;
-struct Ast_Type;
-struct Ast;
-struct Ast_Expr;
 
 
-enum Token_Kind{
-  TK_End,
-
-/*#
-import meta
-for i in meta.token_kinds:
-  print("  TK_" + i[0] + ",")
-*/
-  TK_Mul,
-  TK_Div,
-  TK_Mod,
-  TK_LeftShift,
-  TK_RightShift,
-  TK_FirstMul = TK_Mul,
-  TK_LastMul = TK_RightShift,
-  TK_Add,
-  TK_Sub,
-  TK_FirstAdd = TK_Add,
-  TK_LastAdd = TK_Sub,
-  TK_Equals,
-  TK_LesserThenOrEqual,
-  TK_GreaterThenOrEqual,
-  TK_LesserThen,
-  TK_GreaterThen,
-  TK_NotEquals,
-  TK_FirstCompare = TK_Equals,
-  TK_LastCompare = TK_NotEquals,
-  TK_BitAnd,
-  TK_BitOr,
-  TK_BitXor,
-  TK_And,
-  TK_Or,
-  TK_FirstLogical = TK_BitAnd,
-  TK_LastLogical = TK_Or,
-  TK_Neg,
-  TK_Not,
-  TK_Decrement,
-  TK_Increment,
-  TK_PostDecrement,
-  TK_PostIncrement,
-  TK_Assign,
-  TK_ColonAssign,
-  TK_DivAssign,
-  TK_MulAssign,
-  TK_ModAssign,
-  TK_SubAssign,
-  TK_AddAssign,
-  TK_AndAssign,
-  TK_OrAssign,
-  TK_XorAssign,
-  TK_LeftShiftAssign,
-  TK_RightShiftAssign,
-  TK_FirstAssign = TK_Assign,
-  TK_LastAssign = TK_RightShiftAssign,
-  TK_OpenParen,
-  TK_CloseParen,
-  TK_OpenBrace,
-  TK_CloseBrace,
-  TK_OpenBracket,
-  TK_CloseBracket,
-  TK_Comma,
-  TK_Pound,
-  TK_Question,
-  TK_ThreeDots,
-  TK_Semicolon,
-  TK_Dot,
-  TK_TwoDots,
-  TK_NewLine,
-  TK_Colon,
-  TK_DoubleColon,
-  TK_At,
-  TK_Arrow,
-  TK_ExprSizeof,
-  TK_DocComment,
-  TK_Comment,
-  TK_Identifier,
-  TK_UnicodeLit,
-  TK_StringLit,
-  TK_Error,
-  TK_Float,
-  TK_Integer,
-  TK_Keyword,
-/*END*/
-
-  TK_Pointer     = TK_Mul,
-  TK_Dereference = TK_BitAnd,
-
-  OPEN_SCOPE = 128,
-  CLOSE_SCOPE,
-  SAME_SCOPE,
-};
-
-struct Token{
-  Token_Kind kind;
-  U32 di; // debug_id
-  union{
-    String string;
-    struct{U8 *str; S64 len;};
-  };
-
-  union {
-    U32 unicode;
-    BigInt int_val;
-    F64 f64_val;
-    String error_val;
-    Intern_String intern_val;
-    S64 indent;
-  };
-
-  Intern_String file;
-  S32           line;
-  U8           *line_begin;
-};
-
 struct Lex_Stream{
   String stream;
   S64    iter;
diff --git a/core_compiler_interface.hpp b/core_compiler_interface.hpp
new file mode 100644
index 0000000..a05dcd9
--- /dev/null
+++ b/core_compiler_interface.hpp
@@ -0,0 +1,597 @@
+#pragma once
+#include <stdint.h>
+
+struct Ast;
+struct Ast_Scope;
+struct Ast_Decl;
+struct Ast_File_Namespace;
+struct Ast_File;
+struct Ast_Module;
+struct Ast_Lambda;
+struct Ast_Type;
+struct Ast_Expr;
+
+#ifndef CORE_STRINGS
+#define CORE_STRINGS
+struct String{
+  uint8_t *str;
+  int64_t len;
+};
+
+union Intern_String{  // Basically just String
+  String s;
+  struct{ 
+    uint8_t *str; 
+    int64_t len; 
+  };
+};
+#endif
+
+enum Token_Kind{
+  TK_End,
+
+  /*#
+    import meta
+    for i in meta.token_kinds:
+    print("  TK_" + i[0] + ",")
+    */
+  TK_Mul,
+  TK_Div,
+  TK_Mod,
+  TK_LeftShift,
+  TK_RightShift,
+  TK_FirstMul = TK_Mul,
+  TK_LastMul = TK_RightShift,
+  TK_Add,
+  TK_Sub,
+  TK_FirstAdd = TK_Add,
+  TK_LastAdd = TK_Sub,
+  TK_Equals,
+  TK_LesserThenOrEqual,
+  TK_GreaterThenOrEqual,
+  TK_LesserThen,
+  TK_GreaterThen,
+  TK_NotEquals,
+  TK_FirstCompare = TK_Equals,
+  TK_LastCompare = TK_NotEquals,
+  TK_BitAnd,
+  TK_BitOr,
+  TK_BitXor,
+  TK_And,
+  TK_Or,
+  TK_FirstLogical = TK_BitAnd,
+  TK_LastLogical = TK_Or,
+  TK_Neg,
+  TK_Not,
+  TK_Decrement,
+  TK_Increment,
+  TK_PostDecrement,
+  TK_PostIncrement,
+  TK_Assign,
+  TK_ColonAssign,
+  TK_DivAssign,
+  TK_MulAssign,
+  TK_ModAssign,
+  TK_SubAssign,
+  TK_AddAssign,
+  TK_AndAssign,
+  TK_OrAssign,
+  TK_XorAssign,
+  TK_LeftShiftAssign,
+  TK_RightShiftAssign,
+  TK_FirstAssign = TK_Assign,
+  TK_LastAssign = TK_RightShiftAssign,
+  TK_OpenParen,
+  TK_CloseParen,
+  TK_OpenBrace,
+  TK_CloseBrace,
+  TK_OpenBracket,
+  TK_CloseBracket,
+  TK_Comma,
+  TK_Pound,
+  TK_Question,
+  TK_ThreeDots,
+  TK_Semicolon,
+  TK_Dot,
+  TK_TwoDots,
+  TK_NewLine,
+  TK_Colon,
+  TK_DoubleColon,
+  TK_At,
+  TK_Arrow,
+  TK_ExprSizeof,
+  TK_DocComment,
+  TK_Comment,
+  TK_Identifier,
+  TK_UnicodeLit,
+  TK_StringLit,
+  TK_Error,
+  TK_Float,
+  TK_Integer,
+  TK_Keyword,
+  /*END*/
+
+  TK_Pointer     = TK_Mul,
+  TK_Dereference = TK_BitAnd,
+
+  OPEN_SCOPE = 128,
+  CLOSE_SCOPE,
+  SAME_SCOPE,
+};
+
+struct BigInt {
+  unsigned digit_count;
+  bool is_negative;
+  union {
+    uint64_t digit;
+    uint64_t *digits;
+  };
+};
+
+struct Token{
+  Token_Kind kind;
+  uint32_t di; // debug_id
+  union{
+    String string;
+    struct{
+      uint8_t *str; 
+      int64_t len;
+    };
+  };
+
+  union {
+    uint32_t unicode;
+    BigInt int_val;
+    double f64_val;
+    String error_val;
+    Intern_String intern_val;
+    int64_t indent;
+  };
+
+  Intern_String file;
+  int32_t       line;
+  uint8_t      *line_begin;
+};
+
+enum Ast_Type_Kind{
+  TYPE_NONE,
+  TYPE_S64, // FIRST_NUMERIC
+  TYPE_S32,
+  TYPE_S16,
+  TYPE_S8 ,
+  TYPE_INT,
+  TYPE_CHAR,
+  TYPE_U64,
+  TYPE_U32,
+  TYPE_U16,
+  TYPE_U8 ,
+  TYPE_F32,
+  TYPE_F64,
+  TYPE_POINTER,
+  TYPE_BOOL, // LAST_NUMERIC
+  TYPE_STRING,
+  TYPE_VOID,
+  TYPE_ARRAY,
+  TYPE_LAMBDA,
+  TYPE_STRUCT,
+  TYPE_UNION,
+  TYPE_ENUM,
+  TYPE_TYPE,
+  TYPE_SLICE,
+  TYPE_TUPLE,
+
+  TYPE_COMPLETING,
+  TYPE_INCOMPLETE,
+  TYPE_UNTYPED_BOOL, // FIRST_TYPED_NUMERIC, FIRST_NUMERIC
+  TYPE_UNTYPED_INT,
+  TYPE_UNTYPED_FLOAT, // LAST_TYPED_NUMERIC
+  TYPE_UNTYPED_STRING,
+
+  TYPE_UNTYPED_FIRST = TYPE_UNTYPED_BOOL,
+  TYPE_UNTYPED_LAST = TYPE_UNTYPED_STRING,
+
+  TYPE_UNTYPED_FIRST_NUMERIC = TYPE_UNTYPED_BOOL,
+  TYPE_UNTYPED_LAST_NUMERIC  = TYPE_UNTYPED_FLOAT,
+
+  TYPE_FIRST_NUMERIC = TYPE_S64,
+  TYPE_LAST_NUMERIC  = TYPE_BOOL,
+};
+
+struct Value {
+  /*#import meta
+  print(meta.value_struct_content)
+  */
+  Ast_Type *type;
+  Ast_Decl *resolved_decl;
+  union {
+    bool          bool_val;   
+    double           f64_val;    
+    Intern_String intern_val; 
+    BigInt        big_int_val;
+    Ast_Type     *type_val;            
+  };
+  /*END*/
+};
+
+struct Ast_Resolved_Member{
+  Intern_String name;
+  int32_t offset;
+  bool visited;
+  /*#import meta
+    meta.inline_value_fields()
+    */
+  union {
+    Value value;
+    struct {
+      Ast_Type *type;
+      Ast_Decl *resolved_decl;
+      union {
+        bool          bool_val;   
+        double           f64_val;    
+        Intern_String intern_val; 
+        BigInt        big_int_val;
+        Ast_Type     *type_val;            
+      };
+    };
+  };
+  /*END*/
+};
+
+struct Ast_Type{
+  Ast_Type_Kind kind;
+  int32_t size;
+  int32_t align;
+  int32_t is_unsigned;
+  int32_t type_id;
+  int32_t padding;
+
+  Ast *ast;
+  union{
+    Ast_Type *base;
+    struct{
+      Ast_Type *base;
+      int32_t size;
+      // @note: if you have array with size "[32]"
+      // you still want to pass that array into
+      // a function that expects an array of size "[]"
+      // so we want also should check this
+      uint64_t slice_hash;
+    }arr;
+    struct{
+      Array<Ast_Resolved_Member> members;
+    }agg;
+    struct{
+      Ast_Type * ret;
+      Array<Ast_Type *> args;
+      uint64_t hash_without_ret;
+    }func;
+  };
+};
+
+enum Ast_Kind: uint32_t{
+  AST_NONE,
+
+  AST_NAMESPACE,
+
+  AST_MODULE,
+  AST_FILE,
+  AST_SCOPE,
+  AST_VALUE,
+  AST_CAST,
+  AST_IDENT,
+  AST_INDEX,
+  AST_UNARY,
+  AST_BINARY,
+  AST_CALL_ITEM,
+  AST_CALL,
+
+  AST_CONSTANT_ASSERT,
+  AST_RUNTIME_ASSERT,
+  AST_SIZE_OF,
+  AST_LENGTH_OF,
+  AST_ALIGN_OF,
+  AST_TYPE_OF,
+
+  AST_SWITCH,
+  AST_SWITCH_CASE,
+  AST_VAR_UNPACK,
+  AST_BREAK,
+  AST_COMPOUND,
+  AST_TYPE,
+  AST_VAR,
+  AST_CONST,
+  AST_POINTER,
+  AST_ARRAY,
+  AST_FOR,
+  AST_IF,
+  AST_IF_NODE,
+  AST_RETURN,
+  AST_BLOCK,
+  AST_PASS,
+  AST_LAMBDA,
+  AST_LAMBDA_EXPR,
+  AST_LAMBDA_ARG,
+  AST_ENUM,
+  AST_ENUM_MEMBER,
+  AST_STRUCT,
+};
+
+typedef uint32_t Ast_Flag;
+enum{
+  AST_EXPR              = 1ull << 1,
+  AST_STMT              = 1ull << 2,
+  AST_STRICT            = 1ull << 3,
+  AST_AGGREGATE         = 1ull << 4,
+  AST_AGGREGATE_CHILD   = 1ull << 5,
+  AST_ATOM              = 1ull << 7,
+  AST_FOREIGN           = 1ull << 8,
+  AST_DECL              = 1ull << 9,
+  AST_GLOBAL            = 1ull << 10,
+  AST_FLAG              = 1ull << 11,
+  AST_VAR_IS_CONST      = 1ull << 12,
+  AST_OPERATOR_OVERLOAD = 1ull << 13,
+  AST_IS_LVALUE         = 1ull << 14,
+};
+
+struct Ast{
+  uint64_t di; // Debug id, shouldn't ever be used in the program
+  Token *pos;
+
+  Ast_Kind kind;
+  Ast_Scope *parent_scope;
+  Ast_Flag flags;
+};
+
+struct Ast_Expr:Ast{
+  Ast_Type *resolved_type;
+  Ast_Decl *resolved_operator_overload;
+  union{
+    Ast_Type *index_original_type;
+    Ast_Type *cast_after_type;
+    Ast_Type *dot_access_step_resolution;
+  };
+};
+
+struct Ast_Atom: Ast_Expr{
+  // We have a field type here
+  // it has a different purpose from the
+  // resolved_type of Ast_Expr, it describes
+  // the inherent type of a value
+  //
+  // resolved_type is a solid type that
+  // can be use during code generation
+  // it cannot be untyped. (or at least thats the hope :)
+  /*#import meta
+  meta.inline_value_fields()
+  */
+  union {
+    Value value;
+    struct {
+      Ast_Type *type;
+      Ast_Decl *resolved_decl;
+      union {
+        bool          bool_val;   
+        double           f64_val;    
+        Intern_String intern_val; 
+        BigInt        big_int_val;
+        Ast_Type     *type_val;            
+      };
+    };
+  };
+  /*END*/
+};
+
+typedef uint32_t Ast_Call_Item_Flag;
+enum{
+  CALL_INDEX   = 1ull << 1,
+  CALL_NAME    = 1ull << 2,
+  CALL_INCLUDED= 1ull << 4,
+};
+
+struct Ast_Call_Item: Ast_Expr{
+  Ast_Call_Item_Flag call_flags;
+  int32_t resolved_index;
+  Ast_Expr *item;
+  union {
+    Ast_Atom *name;
+    Ast_Expr *index;
+  };
+  Intern_String resolved_name;
+};
+
+struct Ast_Call: Ast_Expr{
+  union{
+    Ast_Expr *name;
+    Ast_Expr *typespec;
+  };
+  Array<Ast_Call_Item *> exprs;
+  Ast_Decl *resolved_decl;
+};
+
+struct Ast_Var_Unpack: Ast_Expr{
+  Array<Ast_Decl *> vars;
+  Ast_Expr *expr;
+};
+
+struct Ast_Unary: Ast_Expr{
+  Token_Kind op;
+  Ast_Expr *expr;
+  uint64_t padding[2]; // For folding constants into atoms
+};
+
+struct Ast_Index: Ast_Expr{
+  Ast_Expr *expr;
+  Ast_Expr *index;
+};
+
+struct Ast_Binary: Ast_Expr{
+  Token_Kind op;
+  Ast_Expr *left;
+  Ast_Expr *right;
+  Ast_Type *before_type;
+};
+
+struct Ast_Builtin: Ast_Expr{
+  Ast_Expr *expr;
+  Intern_String assert_message;
+  uint64_t padding[1]; // For folding constants into atoms
+};
+
+// Problem: We are parsing out of order, in the middle of parsing a function
+// we can jump down a different function, we cant therfore use global map.
+// Each scope needs to have it's checked locals list. To lookup syms we need to
+// look into global scope and to the locals list.
+//
+
+struct Ast_Return: Ast{
+  Ast_Type *resolved_type;
+  Array<Ast_Expr *> expr;
+};
+
+struct Ast_If_Node: Ast{
+  Ast_Expr  *expr ;
+  Ast_Scope *scope;
+  Ast_Binary*init;
+};
+
+struct Ast_If: Ast{
+  Array<Ast_If_Node *> ifs;
+};
+
+struct Ast_Pass: Ast{};
+struct Ast_Break: Ast{};
+
+struct Ast_For: Ast{
+  Ast_Expr *init;
+  Ast_Expr *cond;
+  Ast_Expr *iter;
+  Ast_Scope *scope;
+
+  Ast_Decl *array_traversal_var;
+  bool is_array_traversal;
+  bool is_also_slice_traversal;
+};
+
+struct Ast_Lambda : Ast_Expr {
+  Array<Ast_Decl *> args;
+  Array<Ast_Expr *> ret;
+  Ast_Scope        *scope;
+};
+
+struct Ast_Array: Ast_Expr{
+  Ast_Expr *base;
+  Ast_Expr *expr;
+  uint64_t padding[2];
+};
+
+struct Ast_Switch_Case: Ast{
+  Array<Ast_Expr *> labels;
+  Ast_Scope *scope;
+  bool fallthrough;
+};
+
+struct Ast_Switch: Ast{
+  Ast_Expr *value;
+  Array<Ast_Switch_Case *> cases;
+  Ast_Scope *default_scope;
+};
+
+/*
+  How does current declaration order resolver works:
+  * First we put all the global declarations into the global scope (when parsing) all unresolved
+  * All the types are declared INCOMPLETE and RESOLVED
+  * We descent the tree by resolving each of the named declarations, we resolve by their name
+  When we start resolving we set RESOLVING flag and when we complete RESOLVED flag
+  and put into ordered list
+  * When we meet a symbol (named declaration) while descending the tree,
+  we resolve that symbol instead before resolving current declaration.
+  * When we meet a declaration that requires size of a type - field access, var assignment,
+  we need to call "complete_type", it sets COMPLETING flag.
+  This call resolves all the dependencies of that type,
+  sets size of type and marks it as COMPLETE and puts into ordered list.
+  If it detects COMPLETING while
+  resolving, we got a circular dependency. That might happen when we have
+  that struct without pointer inside itself.
+
+  */
+
+struct Ast_Scope: Ast{
+  String debug_name; // Dont use
+  List<Ast_Scope *> implicit_imports;
+  List<Ast_Decl *>  decls;
+  Array<Ast      *> stmts;
+
+  uint32_t visit_id;
+  uint32_t scope_id;
+  Ast_Scope *file; // Self referential for file and module
+  Ast_Module *module;
+};
+
+enum Ast_Module_State{
+  MODULE_REGISTERED,
+  MODULE_PARSED,
+  MODULE_RESOLVED,
+};
+
+struct Ast_Module: Ast_Scope{
+  Ast_Module_State  state;
+  String            absolute_base_folder;
+  String            absolute_file_path;
+  List<Ast_File *>  all_loaded_files;
+};
+
+struct Ast_File: Ast_Scope{
+  String absolute_base_folder;
+  String absolute_file_path;
+  String filecontent;
+};
+
+enum Ast_Decl_State{
+  DECL_NOT_RESOLVED,
+  DECL_RESOLVED,
+  DECL_RESOLVED_TYPE,
+  DECL_RESOLVING,
+};
+
+struct Ast_Operator_Info{
+  Intern_String op;
+  String name;
+  Token_Kind op_kind;
+  bool valid_binary_expr;
+  bool valid_unary_expr;
+};
+
+struct Ast_Decl: Ast{
+  Ast_Decl_State state;
+  Intern_String name;
+  Intern_String unique_name; // For code generation, currently only present on lambdas
+
+  uint64_t operator_overload_arguments_hash;
+  Ast_Operator_Info *overload_op_info;
+
+  Ast_Scope *scope;
+  Ast_Expr *typespec;
+  union{
+    Ast_Expr *expr;
+    Ast_Lambda *lambda;
+  };
+
+  /*#import meta
+    meta.inline_value_fields()
+    */
+  union {
+    Value value;
+    struct {
+      Ast_Type *type;
+      Ast_Decl *resolved_decl;
+      union {
+        bool          bool_val;   
+        double           f64_val;    
+        Intern_String intern_val; 
+        BigInt        big_int_val;
+        Ast_Type     *type_val;            
+      };
+    };
+  };
+  /*END*/
+};
diff --git a/core_generated.cpp b/core_generated.cpp
index 7d0cf99..5f657ba 100644
--- a/core_generated.cpp
+++ b/core_generated.cpp
@@ -1,11 +1,5 @@
 
-struct Operator_Info{
-  Intern_String op;
-  String name;
-  Token_Kind op_kind;
-  bool valid_binary_expr;
-  bool valid_unary_expr;
-};
+
 
 /*#import meta
 
@@ -40,7 +34,7 @@ print("  return 0;\n}")
 
 
 */
-Operator_Info op_info_table[] = {
+Ast_Operator_Info op_info_table[] = {
   {{}, "MUL"_s, TK_Mul, 1, 0},
   {{}, "DIV"_s, TK_Div, 1, 0},
   {{}, "MOD"_s, TK_Mod, 1, 0},
@@ -62,7 +56,7 @@ Operator_Info op_info_table[] = {
   {{}, "NEG"_s, TK_Neg, 0, 1},
   {{}, "NOT"_s, TK_Not, 0, 1},
 };
-CORE_Static Operator_Info *
+CORE_Static Ast_Operator_Info *
 get_operator_info(Token_Kind op){
   switch(op){
     case TK_Mul: return op_info_table + 0;
@@ -89,7 +83,7 @@ get_operator_info(Token_Kind op){
   }
   return 0;
 }
-CORE_Static Operator_Info *
+CORE_Static Ast_Operator_Info *
 get_operator_info(Intern_String op){
   if(0){}
   else if(op_info_table[0].op.str == op.str) return op_info_table + 0;
diff --git a/core_main.cpp b/core_main.cpp
index e78feed..21440f7 100644
--- a/core_main.cpp
+++ b/core_main.cpp
@@ -268,6 +268,7 @@ For modules it's a bit different cause they should be distributed as valid.
 #error Couldnt figure out OS using macros
 #endif
 
+#include "core_compiler_interface.hpp"
 #include "c3_big_int.h"
 #include "core_compiler.h"
 #include "core_types.h"
diff --git a/core_parsing.cpp b/core_parsing.cpp
index b3f3526..c70514b 100644
--- a/core_parsing.cpp
+++ b/core_parsing.cpp
@@ -864,7 +864,7 @@ parse_decl(B32 is_global){
     if(!expr->scope){
       compiler_error(tname, "Operator overload doesn't have body");
     }
-    Operator_Info *op_info = get_operator_info(tname->intern_val);
+    Ast_Operator_Info *op_info = get_operator_info(tname->intern_val);
     if(!op_info){
       compiler_error(tname, "This operator cannot be overloaded");
     }
diff --git a/core_typechecking.cpp b/core_typechecking.cpp
index e0eec16..6ef4567 100644
--- a/core_typechecking.cpp
+++ b/core_typechecking.cpp
@@ -546,7 +546,7 @@ resolve_name(Ast_Scope *scope, Token *pos, Intern_String name, Search_Flag searc
 
 CORE_Static Ast_Decl *
 resolve_operator_overload(Ast_Scope *scope, Ast_Type *left, Ast_Type *right, Token *pos, Token_Kind op, U64 argument_hash){
-  Operator_Info *op_info = get_operator_info(op);
+  Ast_Operator_Info *op_info = get_operator_info(op);
   if(op_info == 0) return 0;
 
   // Search for all possible candidates in three scopes
diff --git a/core_types.h b/core_types.h
index 17d4294..b3a7cc1 100644
--- a/core_types.h
+++ b/core_types.h
@@ -1,49 +1,7 @@
 //-----------------------------------------------------------------------------
 // Resolved Types
 //-----------------------------------------------------------------------------
-enum Ast_Type_Kind{
-  TYPE_NONE,
-  TYPE_S64, // FIRST_NUMERIC
-  TYPE_S32,
-  TYPE_S16,
-  TYPE_S8 ,
-  TYPE_INT,
-  TYPE_CHAR,
-  TYPE_U64,
-  TYPE_U32,
-  TYPE_U16,
-  TYPE_U8 ,
-  TYPE_F32,
-  TYPE_F64,
-  TYPE_POINTER,
-  TYPE_BOOL, // LAST_NUMERIC
-  TYPE_STRING,
-  TYPE_VOID,
-  TYPE_ARRAY,
-  TYPE_LAMBDA,
-  TYPE_STRUCT,
-  TYPE_UNION,
-  TYPE_ENUM,
-  TYPE_TYPE,
-  TYPE_SLICE,
-  TYPE_TUPLE,
 
-  TYPE_COMPLETING,
-  TYPE_INCOMPLETE,
-  TYPE_UNTYPED_BOOL, // FIRST_TYPED_NUMERIC, FIRST_NUMERIC
-  TYPE_UNTYPED_INT,
-  TYPE_UNTYPED_FLOAT, // LAST_TYPED_NUMERIC
-  TYPE_UNTYPED_STRING,
-
-  TYPE_UNTYPED_FIRST = TYPE_UNTYPED_BOOL,
-  TYPE_UNTYPED_LAST = TYPE_UNTYPED_STRING,
-
-  TYPE_UNTYPED_FIRST_NUMERIC = TYPE_UNTYPED_BOOL,
-  TYPE_UNTYPED_LAST_NUMERIC  = TYPE_UNTYPED_FLOAT,
-
-  TYPE_FIRST_NUMERIC = TYPE_S64,
-  TYPE_LAST_NUMERIC  = TYPE_BOOL,
-};
 
 #define CASE_SINT case TYPE_S8:case TYPE_S16:case TYPE_S32:case TYPE_S64: case TYPE_CHAR: case TYPE_INT
 #define CASE_UINT case TYPE_U8:case TYPE_U16:case TYPE_U32:case TYPE_U64
@@ -53,76 +11,3 @@ enum Ast_Type_Kind{
 #define CASE_STRING case TYPE_UNTYPED_STRING: case TYPE_STRING: case TYPE_POINTER
 #define CASE_UNTYPED case TYPE_UNTYPED_INT: case TYPE_UNTYPED_BOOL: case TYPE_UNTYPED_FLOAT: case TYPE_UNTYPED_STRING
 #define ARRAY_SIZE_SLICE (-1)
-
-struct Value {
-/*#import meta
-print(meta.value_struct_content)
-*/
-Ast_Type *type;
-Ast_Decl *resolved_decl;
-union {
-    bool          bool_val;   
-    F64           f64_val;    
-    Intern_String intern_val; 
-    BigInt        big_int_val;
-    Ast_Type     *type_val;            
-};
-/*END*/
-};
-
-struct Ast;
-struct Ast_Type;
-struct Ast_Resolved_Member{
-  Intern_String name;
-  S32 offset;
-  B32 visited;
-/*#import meta
-meta.inline_value_fields()
-*/
-union {
-    Value value;
-    struct {
-        Ast_Type *type;
-Ast_Decl *resolved_decl;
-union {
-    bool          bool_val;   
-    F64           f64_val;    
-    Intern_String intern_val; 
-    BigInt        big_int_val;
-    Ast_Type     *type_val;            
-};
-    };
-};
-/*END*/
-};
-
-struct Ast_Type{
-  Ast_Type_Kind kind;
-  S32 size;
-  S32 align;
-  S32 is_unsigned;
-  S32 type_id;
-  S32 padding;
-
-  Ast *ast;
-  union{
-    Ast_Type *base;
-    struct{
-      Ast_Type *base;
-      S32 size;
-      // @note: if you have array with size "[32]"
-      // you still want to pass that array into
-      // a function that expects an array of size "[]"
-      // so we want also should check this
-      U64 slice_hash;
-    }arr;
-    struct{
-      Array<Ast_Resolved_Member> members;
-    }agg;
-    struct{
-      Ast_Type * ret;
-      Array<Ast_Type *> args;
-      U64 hash_without_ret;
-    }func;
-  };
-};
diff --git a/meta.py b/meta.py
index b4a7285..075b5f9 100644
--- a/meta.py
+++ b/meta.py
@@ -136,7 +136,7 @@ Ast_Type *type;
 Ast_Decl *resolved_decl;
 union {
     bool          bool_val;   
-    F64           f64_val;    
+    double        f64_val;    
     Intern_String intern_val; 
     BigInt        big_int_val;
     Ast_Type     *type_val;