From b6b9fb6be7e228909904c9ed8518561d30d0d828 Mon Sep 17 00:00:00 2001
From: Brendan Hansen <brendan.f.hansen@gmail.com>
Date: Thu, 9 Jul 2020 17:40:19 -0500
Subject: [PATCH] MAJOR BREAKING CHANGES Everything is broken right now

---
 Makefile               |   1 +
 include/onyxastnodes.h | 306 ++++++++++++++---------------
 include/onyxlex.h      |  80 ++++----
 include/onyxparser.h   |   4 +-
 include/onyxsempass.h  |   2 +-
 include/onyxtypes.h    |  86 +++++++++
 include/onyxutils.h    |   2 +-
 onyx                   | Bin 225096 -> 227448 bytes
 progs/test.onyx        |   1 +
 src/onyx.c             |  20 +-
 src/onyxchecker.c      | 140 +++++++-------
 src/onyxlex.c          |  70 +++----
 src/onyxparser.c       | 424 ++++++++++++++++++++---------------------
 src/onyxsempass.c      |  32 ++--
 src/onyxsymres.c       | 104 +++++-----
 src/onyxtypes.c        |  49 +++++
 src/onyxutils.c        |   2 +-
 src/onyxwasm.c         | 192 +++++++++----------
 18 files changed, 812 insertions(+), 703 deletions(-)
 create mode 100644 include/onyxtypes.h
 create mode 100644 src/onyxtypes.c

diff --git a/Makefile b/Makefile
index 36a8fbd2..3dbbbe5e 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,7 @@
 OBJ_FILES=\
     build/onyxlex.o \
     build/onyxparser.o \
+	build/onyxtypes.o \
     build/onyxsempass.o \
     build/onyxsymres.o \
     build/onyxchecker.o \
diff --git a/include/onyxastnodes.h b/include/onyxastnodes.h
index ecc36099..a19b4954 100644
--- a/include/onyxastnodes.h
+++ b/include/onyxastnodes.h
@@ -2,249 +2,221 @@
 #define ONYXASTNODES_H
 
 #include "onyxlex.h"
+#include "onyxtypes.h"
 
 typedef struct AstNode AstNode;
-typedef struct AstNodeTyped AstNodeTyped;
-typedef struct AstNodeUnaryOp AstNodeUnaryOp;
-typedef struct AstNodeBinOp AstNodeBinOp;
-typedef struct AstNodeAssign AstNodeAssign;
-typedef struct AstNodeNumLit AstNodeNumLit;
-typedef struct AstNodeLocal AstNodeLocal;
-typedef struct AstNodeLocalGroup AstNodeLocalGroup;
-typedef struct AstNodeReturn AstNodeReturn;
-typedef struct AstNodeBlock AstNodeBlock;
-typedef struct AstNodeIf AstNodeIf;
-typedef struct AstNodeWhile AstNodeWhile;
-typedef struct AstNodeFunction AstNodeFunction;
-typedef struct AstNodeForeign AstNodeForeign;
-typedef struct AstNodeGlobal AstNodeGlobal;
-typedef struct AstNodeCall AstNodeCall;
-typedef struct AstNodeIntrinsicCall AstNodeIntrinsicCall;
-typedef struct AstNodeArgument AstNodeArgument;
-typedef struct AstNodeUse AstNodeUse;
-
-typedef enum AstNodeKind {
-    AST_NODE_KIND_ERROR,
-    AST_NODE_KIND_PROGRAM,
-    AST_NODE_KIND_USE,
-
-    AST_NODE_KIND_FUNCTION,
-    AST_NODE_KIND_FOREIGN,
-    AST_NODE_KIND_BLOCK,
-    AST_NODE_KIND_LOCAL_GROUP,
-    AST_NODE_KIND_LOCAL,
-    AST_NODE_KIND_GLOBAL,
-    AST_NODE_KIND_SYMBOL,
-
-    AST_NODE_KIND_UNARY_OP,
-    AST_NODE_KIND_BIN_OP,
-
-    AST_NODE_KIND_TYPE,
-    AST_NODE_KIND_LITERAL,
-    AST_NODE_KIND_PARAM,
-    AST_NODE_KIND_ARGUMENT,
-    AST_NODE_KIND_CALL,
-    AST_NODE_KIND_INTRINSIC_CALL,
-    AST_NODE_KIND_ASSIGNMENT,
-    AST_NODE_KIND_RETURN,
-
-    AST_NODE_KIND_IF,
-    AST_NODE_KIND_WHILE,
-    AST_NODE_KIND_BREAK,
-    AST_NODE_KIND_CONTINUE,
-
-    AST_NODE_KIND_COUNT
-} AstNodeKind;
-
-typedef enum TypeInfoKind {
-    TYPE_INFO_KIND_UNKNOWN,
-    TYPE_INFO_KIND_VOID,
-    TYPE_INFO_KIND_BOOL,
-
-    TYPE_INFO_KIND_UINT32,
-    TYPE_INFO_KIND_UINT64,
-
-    TYPE_INFO_KIND_INT32,
-    TYPE_INFO_KIND_INT64,
-
-    TYPE_INFO_KIND_FLOAT32,
-    TYPE_INFO_KIND_FLOAT64,
-    TYPE_INFO_KIND_SOFT_FLOAT, // 64-bits of data but could be treated as 32-bit
-} TypeInfoKind;
-
-typedef struct TypeInfo {
-    TypeInfoKind kind;
-    u32 size; // in bytes
-    const char* name;
-    u32 is_int : 1;
-    u32 is_unsigned : 1;
-    u32 is_float : 1;
-    u32 is_bool : 1;
-    u32 is_known : 1;
-} TypeInfo;
-
-extern TypeInfo builtin_types[];
+typedef struct AstTyped AstTyped;
+typedef struct AstUnaryOp AstUnaryOp;
+typedef struct AstBinOp AstBinaryOp;
+typedef struct AstAssign AstAssign;
+typedef struct AstNumLit AstNumLit;
+typedef struct AstLocal AstLocal;
+typedef struct AstLocalGroup AstLocalGroup;
+typedef struct AstReturn AstReturn;
+typedef struct AstBlock AstBlock;
+typedef struct AstIf AstIf;
+typedef struct AstWhile AstWhile;
+typedef struct AstFunction AstFunction;
+typedef struct AstForeign AstForeign;
+typedef struct AstGlobal AstGlobal;
+typedef struct AstCall AstCall;
+typedef struct AstIntrinsicCall AstIntrinsicCall;
+typedef struct AstArgument AstArgument;
+typedef struct AstUse AstUse;
+
+typedef enum AstKind {
+    Ast_Kind_Error,
+    Ast_Kind_Program,
+    Ast_Kind_Use,
+
+    Ast_Kind_Function,
+    Ast_Kind_Foreign,
+    Ast_Kind_Block,
+    Ast_Kind_Local_Group,
+    Ast_Kind_Local,
+    Ast_Kind_Global,
+    Ast_Kind_Symbol,
+
+    Ast_Kind_Unary_Op,
+    Ast_Kind_Binary_Op,
+
+    Ast_Kind_Type,
+    Ast_Kind_Literal,
+    Ast_Kind_Param,
+    Ast_Kind_Argument,
+    Ast_Kind_Call,
+    Ast_Kind_Intrinsic_Call,
+    Ast_Kind_Assignment,
+    Ast_Kind_Return,
+
+    Ast_Kind_If,
+    Ast_Kind_While,
+    Ast_Kind_Break,
+    Ast_Kind_Continue,
+
+    Ast_Kind_Count
+} AstKind;
 
 // NOTE: Some of these flags will overlap since there are
 // only 32-bits of flags to play with
-typedef enum OnyxAstFlags {
+typedef enum AstFlags {
     // Top-level flags
-    ONYX_AST_FLAG_EXPORTED        = BH_BIT(0),
-    ONYX_AST_FLAG_LVAL            = BH_BIT(1),
-    ONYX_AST_FLAG_CONST           = BH_BIT(2),
-    ONYX_AST_FLAG_COMPTIME        = BH_BIT(3),
+    Ast_Flag_Exported        = BH_BIT(0),
+    Ast_Flag_Lval            = BH_BIT(1),
+    Ast_Flag_Const           = BH_BIT(2),
+    Ast_Flag_Comptime        = BH_BIT(3),
 
     // Function flags
-    ONYX_AST_FLAG_INLINE          = BH_BIT(8),
-    ONYX_AST_FLAG_INTRINSIC       = BH_BIT(9),
-} OnyxAstFlags;
-
-typedef enum OnyxUnaryOp {
-    ONYX_UNARY_OP_NEGATE,
-    ONYX_UNARY_OP_NOT,
-    ONYX_UNARY_OP_CAST,
-} OnyxUnaryOp;
-
-typedef enum OnyxBinaryOp {
-    ONYX_BINARY_OP_ADD           = 0,
-    ONYX_BINARY_OP_MINUS         = 1,
-    ONYX_BINARY_OP_MULTIPLY      = 2,
-    ONYX_BINARY_OP_DIVIDE        = 3,
-    ONYX_BINARY_OP_MODULUS       = 4,
-
-    ONYX_BINARY_OP_EQUAL         = 5,
-    ONYX_BINARY_OP_NOT_EQUAL     = 6,
-    ONYX_BINARY_OP_LESS          = 7,
-    ONYX_BINARY_OP_LESS_EQUAL    = 8,
-    ONYX_BINARY_OP_GREATER       = 9,
-    ONYX_BINARY_OP_GREATER_EQUAL = 10,
-} OnyxBinaryOp;
-
-// NOTE: AstNode and AstNodeTyped need to be EXACTLY the same for
-// all arguments existing in AstNode. I do this to avoid a nested
+    Ast_Flag_Inline          = BH_BIT(8),
+    Ast_Flag_Intrinsic       = BH_BIT(9),
+} AstFlags;
+
+typedef enum UnaryOp {
+    Unary_Op_Negate,
+    Unary_Op_Not,
+    Unary_Op_Cast,
+} UnaryOp;
+
+typedef enum BinaryOp {
+    Binary_Op_Add           = 0,
+    Binary_Op_Minus         = 1,
+    Binary_Op_Multiply      = 2,
+    Binary_Op_Divide        = 3,
+    Binary_Op_Modulus       = 4,
+
+    Binary_Op_Equal         = 5,
+    Binary_Op_Not_Equal     = 6,
+    Binary_Op_Less          = 7,
+    Binary_Op_Less_Equal    = 8,
+    Binary_Op_Greater       = 9,
+    Binary_Op_Greater_Equal = 10,
+} BinaryOp;
+
+// NOTE: AstNode and AstTyped need to be EXACTLY the same for all
+// arguments existing in AstNode. I do this to avoid a nested
 // "inheiritance" where you would have to say node.base.base.next
 // for example
 struct AstNode {
-    AstNodeKind kind;
+    AstKind kind;
     u32 flags;
     OnyxToken *token;
     AstNode *next;
 };
 
-struct AstNodeTyped {
-    AstNodeKind kind;
+struct AstTyped {
+    AstKind kind;
     u32 flags;
     OnyxToken *token;
     AstNode *next;
-    TypeInfo *type;
+    Type *type;
 };
 
-struct AstNodeBinOp {
-    AstNodeTyped base;
+struct AstBinOp {
+    AstTyped base;
 
-    OnyxBinaryOp operation;
+    BinaryOp operation;
 
-    AstNodeTyped *left, *right;
+    AstTyped *left, *right;
 };
 
-struct AstNodeUnaryOp {
-    AstNodeTyped base;
+struct AstUnaryOp {
+    AstTyped base;
 
-    OnyxUnaryOp operation;
+    UnaryOp operation;
 
-    AstNodeTyped *expr;
+    AstTyped *expr;
 };
 
-struct AstNodeAssign {
+struct AstAssign {
     AstNode base;
 
-    AstNodeTyped* lval;
-    AstNodeTyped* expr;
+    AstTyped* lval;
+    AstTyped* expr;
 };
 
-struct AstNodeNumLit {
-    AstNodeTyped base;
+struct AstNumLit {
+    AstTyped base;
 
     union { i32 i; i64 l; f32 f; f64 d; } value;
 };
 
-struct AstNodeLocal {
-    AstNodeTyped base;
+struct AstLocal {
+    AstTyped base;
 
-    AstNodeLocal *prev_local;
+    AstLocal *prev_local;
 };
 
-struct AstNodeReturn {
+struct AstReturn {
     AstNode base;
 
-    AstNodeTyped* expr;
+    AstTyped* expr;
 };
 
-struct AstNodeLocalGroup {
+struct AstLocalGroup {
     AstNode base;
 
-    AstNodeLocalGroup *prev_group;
-    AstNodeLocal *last_local;
+    AstLocalGroup *prev_group;
+    AstLocal *last_local;
 };
 
-struct AstNodeBlock {
+struct AstBlock {
     AstNode base;
 
     AstNode *body;
-    AstNodeLocalGroup *locals;
+    AstLocalGroup *locals;
 };
 
-struct AstNodeIf {
+struct AstIf {
     AstNode base;
 
-    AstNodeTyped *cond;
+    AstTyped *cond;
 
     union {
-        AstNodeIf *as_if;
-        AstNodeBlock* as_block;
+        AstIf *as_if;
+        AstBlock* as_block;
     } true_block, false_block;
 };
 
-struct AstNodeWhile {
+struct AstWhile {
     AstNode base;
 
-    AstNodeTyped *cond;
-    AstNodeBlock *body;
+    AstTyped *cond;
+    AstBlock *body;
 };
 
-struct AstNodeFunction {
-    AstNodeTyped base;
+struct AstFunction {
+    AstTyped base;
 
-    AstNodeBlock *body;
-    AstNodeLocal *params;
+    AstBlock *body;
+    AstLocal *params;
 };
 
-struct AstNodeForeign {
+struct AstForeign {
     AstNode base;
 
     OnyxToken *mod_token, *name_token;
     AstNode *import;
 };
 
-struct AstNodeGlobal {
-    AstNodeTyped base;
+struct AstGlobal {
+    AstTyped base;
 
-    AstNodeTyped *initial_value;
+    AstTyped *initial_value;
 };
 
-struct AstNodeCall {
-    AstNodeTyped base;
+struct AstCall {
+    AstTyped base;
 
-    AstNodeArgument *arguments;     // NOTE: Expressions that form the actual param list
+    AstArgument *arguments;     // NOTE: Expressions that form the actual param list
                                     // They will be chained down using the "next" property
                                     // unless this becomes used by something else
     AstNode *callee;                // NOTE: Function definition node
 };
 
-struct AstNodeArgument {
-    AstNodeTyped base;
+struct AstArgument {
+    AstTyped base;
 
-    AstNodeTyped *value;
+    AstTyped *value;
 };
 
 typedef enum OnyxIntrinsic {
@@ -300,23 +272,23 @@ typedef enum OnyxIntrinsic {
 
 // NOTE: This needs to have 'arguments' in the
 // same position as AstNodeCall
-struct AstNodeIntrinsicCall {
-    AstNodeTyped base;
+struct AstIntrinsicCall {
+    AstTyped base;
 
-    AstNodeArgument *arguments;
+    AstArgument *arguments;
     OnyxIntrinsic intrinsic;
 };
 
-struct AstNodeUse {
+struct AstUse {
     AstNode base;
 
     OnyxToken *filename;
 };
 
 typedef struct OnyxProgram {
-    bh_arr(AstNodeGlobal *) globals;
-    bh_arr(AstNodeFunction *) functions;
-    bh_arr(AstNodeForeign *) foreigns;
+    bh_arr(AstGlobal *) globals;
+    bh_arr(AstFunction *) functions;
+    bh_arr(AstForeign *) foreigns;
 } OnyxProgram;
 
 #endif // #ifndef ONYXASTNODES_H
diff --git a/include/onyxlex.h b/include/onyxlex.h
index f145b410..d6b64092 100644
--- a/include/onyxlex.h
+++ b/include/onyxlex.h
@@ -4,46 +4,46 @@
 #include "bh.h"
 
 typedef enum TokenType {
-    TOKEN_TYPE_ASCII_END            = 256,
-    TOKEN_TYPE_UNKNOWN              = 256,
-    TOKEN_TYPE_END_STREAM           = 257,
-
-    TOKEN_TYPE_COMMENT              = 258,
-
-    TOKEN_TYPE_KEYWORD_STRUCT       = 259,
-    TOKEN_TYPE_KEYWORD_USE          = 260,
-    TOKEN_TYPE_KEYWORD_EXPORT       = 261,
-    TOKEN_TYPE_KEYWORD_IF           = 262,
-    TOKEN_TYPE_KEYWORD_ELSE         = 263,
-    TOKEN_TYPE_KEYWORD_ELSEIF       = 264,
-    TOKEN_TYPE_KEYWORD_RETURN       = 265,
-    TOKEN_TYPE_KEYWORD_FOREIGN      = 266,
-    TOKEN_TYPE_KEYWORD_PROC         = 267,
-    TOKEN_TYPE_KEYWORD_CAST         = 268,
-    TOKEN_TYPE_KEYWORD_WHILE        = 269,
-    TOKEN_TYPE_KEYWORD_BREAK        = 270,
-    TOKEN_TYPE_KEYWORD_CONTINUE     = 271,
-
-    TOKEN_TYPE_RIGHT_ARROW          = 272,
-    TOKEN_TYPE_LEFT_ARROW           = 273,
-
-    TOKEN_TYPE_GREATER_EQUAL        = 274,
-    TOKEN_TYPE_LESS_EQUAL           = 275,
-    TOKEN_TYPE_EQUAL_EQUAL          = 276,
-    TOKEN_TYPE_NOT_EQUAL            = 277,
-    TOKEN_TYPE_PLUS_EQUAL           = 278,
-    TOKEN_TYPE_MINUS_EQUAL          = 279,
-    TOKEN_TYPE_STAR_EQUAL           = 280,
-    TOKEN_TYPE_FSLASH_EQUAL         = 281,
-    TOKEN_TYPE_PERCENT_EQUAL        = 282,
-
-    TOKEN_TYPE_SYMBOL               = 283,
-    TOKEN_TYPE_LITERAL_STRING       = 284,
-    TOKEN_TYPE_LITERAL_NUMERIC      = 285,
-    TOKEN_TYPE_LITERAL_BOOL_TRUE    = 286,
-    TOKEN_TYPE_LITERAL_BOOL_FALSE   = 287,
-
-    TOKEN_TYPE_COUNT                = 288
+    Token_Type_Ascii_End            = 256,
+    Token_Type_Unknown              = 256,
+    Token_Type_End_Stream           = 257,
+
+    Token_Type_Comment              = 258,
+
+    Token_Type_Keyword_Struct       = 259,
+    Token_Type_Keyword_Use          = 260,
+    Token_Type_Keyword_Export       = 261,
+    Token_Type_Keyword_If           = 262,
+    Token_Type_Keyword_Else         = 263,
+    Token_Type_Keyword_Elseif       = 264,
+    Token_Type_Keyword_Return       = 265,
+    Token_Type_Keyword_Foreign      = 266,
+    Token_Type_Keyword_Proc         = 267,
+    Token_Type_Keyword_Cast         = 268,
+    Token_Type_Keyword_While        = 269,
+    Token_Type_Keyword_Break        = 270,
+    Token_Type_Keyword_Continue     = 271,
+
+    Token_Type_Right_Arrow          = 272,
+    Token_Type_Left_Arrow           = 273,
+
+    Token_Type_Greater_Equal        = 274,
+    Token_Type_Less_Equal           = 275,
+    Token_Type_Equal_Equal          = 276,
+    Token_Type_Not_Equal            = 277,
+    Token_Type_Plus_Equal           = 278,
+    Token_Type_Minus_Equal          = 279,
+    Token_Type_Star_Equal           = 280,
+    Token_Type_Fslash_Equal         = 281,
+    Token_Type_Percent_Equal        = 282,
+
+    Token_Type_Symbol               = 283,
+    Token_Type_Literal_String       = 284,
+    Token_Type_Literal_Numeric      = 285,
+    Token_Type_Literal_True         = 286,
+    Token_Type_Literal_False        = 287,
+
+    Token_Type_Count                = 288
 } TokenType;
 
 typedef struct OnyxFilePos {
diff --git a/include/onyxparser.h b/include/onyxparser.h
index 37743009..98c67d43 100644
--- a/include/onyxparser.h
+++ b/include/onyxparser.h
@@ -20,8 +20,8 @@ typedef struct OnyxParser {
     bh_allocator allocator;
 } OnyxParser;
 
-const char* onyx_ast_node_kind_string(AstNodeKind kind);
-void* onyx_ast_node_new(bh_allocator alloc, i32 size, AstNodeKind kind);
+const char* onyx_ast_node_kind_string(AstKind kind);
+void* onyx_ast_node_new(bh_allocator alloc, i32 size, AstKind kind);
 OnyxParser onyx_parser_create(bh_allocator alloc, OnyxTokenizer *tokenizer, OnyxMessages* msgs);
 void onyx_parser_free(OnyxParser* parser);
 bh_arr(AstNode *) onyx_parse(OnyxParser *parser);
diff --git a/include/onyxsempass.h b/include/onyxsempass.h
index 220fe8b2..287c4b33 100644
--- a/include/onyxsempass.h
+++ b/include/onyxsempass.h
@@ -19,7 +19,7 @@ typedef struct OnyxSemPassState {
     OnyxMessages *msgs;
 
     // NOTE: Used in symbol resolution phase
-    AstNodeLocalGroup* curr_local_group;
+    AstLocalGroup* curr_local_group;
 
     // NOTE: Used in type checking phase
     TypeInfo* expected_return_type;
diff --git a/include/onyxtypes.h b/include/onyxtypes.h
new file mode 100644
index 00000000..5a50ba4b
--- /dev/null
+++ b/include/onyxtypes.h
@@ -0,0 +1,86 @@
+#ifndef ONYXTYPES_H
+#define ONYXTYPES_H
+
+#include "bh.h"
+
+enum BasicKind {
+    Basic_Kind_Void,
+
+    Basic_Kind_Bool,
+
+    Basic_Kind_I8,
+    Basic_Kind_U8,
+    Basic_Kind_I16,
+    Basic_Kind_U16,
+    Basic_Kind_I32,
+    Basic_Kind_U32,
+    Basic_Kind_I64,
+    Basic_Kind_U64,
+
+    Basic_Kind_F32,
+    Basic_Kind_F64,
+
+    Basic_Kind_Rawptr,
+};
+
+enum BasicFlag {
+    Basic_Flag_Boolean          = BH_BIT(0),
+    Basic_Flag_Integer          = BH_BIT(1),
+    Basic_Flag_Unsigned         = BH_BIT(2),
+    Basic_Flag_Float            = BH_BIT(3),
+    Basic_Flag_Pointer          = BH_BIT(4),
+
+    Basic_Flag_Numeric          = Basic_Flag_Integer | Basic_Flag_Float,
+    Basic_Flag_Ordered          = Basic_Flag_Integer | Basic_Flag_Float | Basic_Flag_Pointer,
+    Basic_Flag_Constant_Type    = Basic_Flag_Boolean | Basic_Flag_Numeric | Basic_Flag_Pointer,
+    Basic_Flag_Numeric_Ordered  = Basic_Flag_Numeric | Basic_Flag_Ordered,
+};
+
+typedef struct TypeBasic {
+    enum BasicKind kind;
+    u32 flags;
+    i64 size; // NOTE: In bytes
+    const char* name;
+} TypeBasic;
+
+// NOTE: Forward declaration for some of the types below
+typedef struct Type Type;
+
+#define TYPE_KINDS \
+    TYPE_KIND(Basic, TypeBasic)                       \
+    TYPE_KIND(Pointer, struct { Type *elem; })
+
+typedef enum TypeKind {
+    Type_Kind_Invalid,
+
+#define TYPE_KIND(k, ...) Type_Kind_##k,
+    TYPE_KINDS
+#undef TYPE_KIND
+
+    Type_Kind_Count,
+} TypeKind;
+
+#define TYPE_KIND(k, ...) typedef __VA_ARGS__ Type ## k;
+    TYPE_KINDS
+#undef TYPE_KIND
+
+enum TypeFlag {
+    Type_Flag_Default
+};
+
+struct Type {
+    TypeKind kind;
+
+    union {
+#define TYPE_KIND(k, ...) Type##k k;
+        TYPE_KINDS
+#undef TYPE_KIND
+    };
+
+    u32 flags;
+};
+
+extern Type basic_types[];
+
+
+#endif // #ifndef ONYX_TYPES
diff --git a/include/onyxutils.h b/include/onyxutils.h
index 86cac2fa..5154227c 100644
--- a/include/onyxutils.h
+++ b/include/onyxutils.h
@@ -8,6 +8,6 @@ extern bh_allocator global_scratch_allocator;
 extern bh_managed_heap global_heap;
 extern bh_allocator global_heap_allocator;
 
-const char* onyx_ast_node_kind_string(AstNodeKind kind);
+const char* onyx_ast_node_kind_string(AstKind kind);
 
 void onyx_ast_print(AstNode* program, i32 indent);
diff --git a/onyx b/onyx
index aeaff62dad6084b1132b65650cf6ecd9d46eebae..6d1375199e08677a71833fbb674e66d6bfc52d42 100755
GIT binary patch
delta 77419
zcmeFa33wF6_BY(slbPumGE0(4$iA@!2oUy7l%1#`K|mIfMFc@n5CXC&!=~&@Xs}R`
zMNpAl!xdzaMFa#?6cmsh6oa6GqJm)N`<<%p&X9Yr-~HeB-tT>%=l$k+D(6>Kr%s)&
zuCC?Ol6|K=H?Df-WT~457gTxEJtsyHzd11lUsrd{FUN#$z8=MDxQ;cKamVy~Sq=9-
zP5K%%(kHMNGmZ?FtflEmhh#gcS5{XAreEn?X81Ap{-cdgPuDNc|90Hoa*o0x^{f_b
zP$<(IQk5kSN`LQC;cpn>Q%Z%eG{V=H3SVP{A1f99juEbG5cvcZGvmJ*5m_?A3V+`S
z&np$a)d(M1Dtw0#zNA$6ZX<l(9pOPm*=Iyty(2<V4jSR{f4j4U4jJK1ONCGABKdMl
zg-<ua^Gb!kP2tF2=~^mcyOE%GsqoK@@ByX5i;VCgrNYZ}l?sh46`p2<k3%@+ZxwX|
zBVtOa1ig*$Ii<oE7~u;_g&#7)my`;3casXOC<zz&D_KUw`jQAyd-II&O{K!e8R0uh
zh3_!J_mv9&&ImtSDm<rqP-;|EDxzL@8Gf}?_}xbMjZ)#wjd0~Xna-@#_Z#6_sql_Q
zxIb7bqMH#BUn;zp5uRQuyq^)CRVsXt5uQ^je3%j5zz7eTnvOCenwCm1&Ir#f75;(|
zo>wY-rV-w?RJd-0_r5bcs4O%h2HY8;EH%Q1lnP&OgpVv0zR?IDS1SAiBYaA!@SP&O
zhoa0W6|vVyu%J}<Cr0>^QsG}2;VVjoYflxP_g(b9oBk53crk-1xidY31!<C-#*|QO
ztyxUDJ|}l(lbiD>(*E;2eQQP~*T=$Fch@}qN=74f{yaS^vywV!p57tzA=US}{&r>!
zwZkF(>&y!5v$^Ho&X}kp@pStnkg1>N&W!C+4gRUW=T6<Ti9VsC?fU+5k9c32%akdq
z@4Z%`DfVe|^}6N9v(<$g%dfSojrQq}R~fFh+ozwdlFGg){IkkSOdYmIpP&6K`=iiP
z?JJgX*Ior8_vB7JnmhGStEp$-&w}9Gsb9-%ih5lsjHuC{vETJ4bMhH4JezZXsqP2#
zHMQ2L`P&P7)E=m^^uj%L2Q$yOdy#PB?sPouj9_8&`n{PNlUumFK@;Y>|9SBoZJ*ck
zItSFg=jJv_QPr(_TBGu6>bb&Jjb2l=ChsHl%;B5#bDfja9;XYPO-@9x!-W@`O|tp=
zJ%i*8TiqD$g6yu(6pm=sNoAJ{545?;*h+otz4h3K`Y-ops^w1<mc6g1O>J7c@Y!}7
zZR+G2g*hD#GWNdy=Yxsr-}>qa9UoGwF4dpuI6!Uvx_+W#raJDR9_rYEy{32Qv`ejW
zP>=0g%VmF5XzO^Cv}J$l{W@1voAuFWc5bV-UZU4r7spT6U}e;PAL&b9P2qVBn5LI|
zsI&f1e_!y%bY<cVmhYT+L(NaQ+#+{+tE(bpco)DMxs6+0_08MidvC|(JTpoieh<Oi
z>3N!9nch^(o%&Vo)V)Qog+igrS*Td)w-sfxcr7#QUcN=e)Z{uy(WZ|>p*fe?98niO
z{;+fIRDDUube%u6)b&Cy@dz*W(wlYZ$GYfmb!p_<+EavW>q(DQSlp$qBXa-FPzbLq
z@8M=W9??7WkKy;I%%OMfIYOPeTR+tEdIbM46w=rAOk?@_;@;`H)_YjQ*<CV7-L^|#
z(tD`;UihK;*~|Cn>Ah3*hJDJiGJ1zT9TQ%@2DLj<ZJJs4)K#JOk03>T^lg2fR&#bD
zb(-Gx(V^;VJM<loc5=1Z5ekV%(ewJp>9zZ=^c4N5DAOa<+y$umCkwyt%T-VQm6D(V
zg|qrsaH0lmc<MpM^+Qi*v+jDGr(ab+ZLWX*bX8VR_~+Ag7^|Y!8dBcz@C9V8>OF>}
zI9n1tvrZp3B)MHR!duscLNDwX9=W&GF&p%~)Y1-Z>3!k5nAs$nSY9q+i6EAYJ6L`{
z50(+@^h-mM9cKu4)XO}R;@C|vN3RaJf}lt5@JvdTnFPOIYh~#oc|#$!B+H@1vUjb%
z;F)A+7sAWe>RW*CB0PSre)^eYM<(H(bBCt1(+D*#5$Gj>AL2<$1paUiEb%2QK4MvN
z2g?`4^6MJ?iJ{5P&4j;Lqt66hOnBWIef`knwi5}@SYxS9<JwDsJH!kimVqTK0b;qP
zhAY#KSX%4x!%`fz2$s_u1C}MI=sky}wEOcc;HlMCHt{5*-yJe85X<HgmIPvHeh14w
zV&SXxeZ!KSYYFGC)-MlBcFZT-LHFdRIG!U|UC+r+Y1fZnnG%7i3Iw9v4J*X^iKS?j
zrB)iT47r0Phgd#ZrN5G&?2IM+`YL@JaOezhaFu>GKe_EUgnN{TDMw<y!Jm@XwVzlT
zmavp3mYsL7yhAK;dhYNP=K_Mitkee$PjF5me0Zfk1NbSzg)8;dz?})}EA@lGO$ZNL
zsb3jhj<qfHk0{R=)9XHaFFT_LpS?dd?R3c}76Y8i4u#G_x2yOHCpRoCdbS^9d4&&*
zif1fMe|&Uj_PxGsbkFo%C-Av9q0*RHcfr?0nk)k;`hIyRbnvo!j=tlG%)&>;AhU(~
zgy-(_3_o6y&A`Ir&+TTcNMAIz9otoSWo$!Lol;w`H2${w^=mxc%>sJE36)s1-e*Fa
z^y6PCitPSgdJ!U8UCHfxD0jN&bZybRovE$wn^2y0(0`ba%<AawiRI8JRG&DPeWLH2
z__umTbBHTKeT16JZ*wPJ@#ju`{>Ied*U`?N_!3W0i%NNB-S>g<1iL_rhP|q<o>V@#
zG^||aTjes-z7jl_jyj3ozJ~AtiB}NbF7YbDg%YnO{FcOP3BMYKXG<((PL%jf;(68?
z6dAllo+o9*+k|^bEW$fVyo|!zNGz0SEb(#*uOad4gv*8Tmkr}7Bk>!=6T(yz5BAoV
z$p6wW(jzkdE)1Ut!=HuW55w?AiA4#mlK36UV6nvS5!NN%LU^*o+X;^W4nm6$$un3+
z>?7P);!g;7k@yS3_e*?~@I4YABV1eJ<Af_o{59buiKzx$@=1J}uubCgz`;wuQ=322
z{w+mZmiQ9kGZOzm_^`xR3GbEo7s6X4zD{_Z#J>_=Ch>2Cxx~K{o*ot+6gX%XiHFIE
zpNZ-5F#K>BZXbqQgyH&OxM~<q3&SyC*eUTf%Ij8;dZ?N9pUCr*#NvrBgyExM_&^xm
z9)=6U@LOT{)i69e3{RB!a*#59R(eFSKPmBd6y8f>@oG9se1XE-NPLcPV~NiYt|9R$
z!sR3u@4l?WqJET-Sk$4A4U=g+{g;&B7wYh4+K&+aPU6FaPe?3yJ`3X!UGYr2;Mpj{
zMI~JomUeL%zb>(mGg;!VzC`|)#)L%-mRJbwE3pvTMdHs%q5H$a?+N3t9fm7~;iNEr
zpTt6rjd0L-g5Rl=ooN@DU6xodosswuWqdd+d~X>47Kw$@>m(MXxGXH3ODtqgmsrRQ
z2BqgS%3xSn#N%NJ9uC9p!*Gi*{`wLNIaR}OS{P4^#6k(D#6h9yEz!ZrcmI>b;%P2O
zEK235#3JzliNzCamsn(6DDkKCFmFjL(!MIONIP3%k#-`J?Z5Cm8^-ixSYizNtxDQ4
z47ZV3JV0ZKh0--778#RK60cQcTvlR{R~d;v6YYOUbdItn|01#YJie1yd`=h!kRb8-
zeI~K^TtAdpv>zKK7A@c^iEmL!ES8v|hrgst>?AxHnA(32JeS7;#1R+{kVaq-Ko)_%
z05u782WUi~13)tZxd8VOxCfvkfqDQv2vh^;N1!~wAOcAMqX|R<Od;UPwav7@RQTbH
zJxt9n(DUZR7A~2!mZ|Gz7v{}*m8JcB3}c5lQC4+FAE6RxG8v>OaaJf)^y^IBJ-4f;
z1p>_JOnrUu+#BjkGxXq+x`m7M#Vm0L3Se_{DIx1~Az>*<(Y|SVm-(sclxfH`RWI6`
zQuyxt+cws|aNWzz9L%F%TRcM@7lfSet1bUXWH7bW$%)UOWW&=irg`~eNc~7ky|i0M
zt-c3Rr;aUrX{nE?T`?t}6RR(oRk85=>(%Y*56>F@D*ED?j>0Z0BANQi2qUbLzVz+>
zvA=CAd5rIY#rRNf_G;t8E-Py%q%V65Id&4?Ox+W&iyWITM~-89&^)p8G5wMG@oM89
zLgeueTYFwdq**F26=v`5XscRfsX4;i-i!ozwk?Cq*QCrZ7YUh(;3*p3RbRO`mDMf$
zc<-YsJFjQ&-_1OQ*Y=lX+OHkO)HX*im=)vRlsk3!dc4Zlzt^iBT&jjH>4y%cs%I|g
zR}T(!<zIrpsh<@k>yLi&fx4zh&;0ZjyIW8FY_$4eNBx!0mavM2jSv0Cw1e%0$RQ+B
zZ~Mj5?1H}Ki@Vrk`i(C}tC!mA`G<eeUb-JVGy7d7p27)7x~d8KJm@}Kw5D~Z&lb8L
zDuC`)3xE0Q5$1Y|Mv~L*PoLJi9UJeua7y^TIi+7XR?f9i`Zk@?eaB;6FH7Gmr}S#a
zQ*(w&-!LLGXEuecAa~-<0m5{!i=Jj`9!ZM5U$V75wQS6BrcP*8`25%RMX-AMzSFbS
zH=EMXy1f4UnM3OOdkWj1jb`e?yY=>GvkPaRdxEJEO$4rV;U-g0H6pCfKIbUx^sQZ0
zmp9NK{_d8_>+4;ME~#7V=`AizQ2z|-doP_(AFgZ4)d~-N|2<P%)RqBfuhjBve6Hkm
zuPRLYp&V1U)P(Fx`jbEYrY_8p+5gm*u}uBs)%vcLsMC0kRUhfe*U}P#BjJN>WG2iZ
zxiecG+KfILpzf1;r)!(lpQ`EppHHzlg+Ko6v8m^)=zsoNB`dB9%qW$p=3x%A&#<j@
zKw$3FRyQvDWZ>SS_Imr@Myp4%^aH<r&YJ13{a#fao>jR2_i9Xisgi#4#%Xm=g~H=E
z(^WR3@Q+)YRP{iHzM;6h3X9d(#rLaOoAgSd6g6R!-a0f*ow-r}B9s*zhIWo7b-wqS
zs#EO!OMGmKy_@Azrr6uTbGg1`g}1R4*A$%9OMH-$QR1^ru?NUE)9wb5Gn$`$QLT!m
zKK~60r)d5t76=x-XX)UWVn0#hvrn;qTH=eCV&7TfgX9e*KIHmVi4PjRV)>x#EO;&t
zwsaq9#gXn$_9*c}OwSS@vglCaL-s98d{C`^i4SU5De*a{*i*<i)9!nZ4`8f$W$g)g
z>0Q>?+v+-6I*R*apb?gYFti&K_5(l6SfQr{qRjTDKG#*&N&PB?UsBl=)`JhVv4!eq
zN!%a7QrHk)J%Zh(>PdW11goMxo5UAHuou*`i9F5Dx~VTD@*&x*9DmKu8mg5<U^#xv
z&gzvvm=FpHdmK$L(=ov;+S}>|l%UE`G+jac{Uc#xX9ruYs<-3xEjcMX-NlO4GqLoU
zJgiQL<<Gm>SL(_D`Lp=*Wms+2j=xieon}w-IgzY}`sqr(Gm<5$@2=#hBH4L%H{ao5
zRlTpnh+6cPoU^?2KELT<H=L1Cp-|iD{rFF5tRheKAyMajypfO9bY<?NLfTv8=J`H$
zLoM)aeA>@E%rl{TNePYMQ=-^S^*Ilp7|pJG7IiI&n!9mQ42xoH0DmdKzV>W;s3hv0
zjnBujy%DV8##V{!Et^`P@*h)JoO+XSM=E=fWo(?8%33k?gtGBS8tbL1)BfajGubfK
zioc!7{$x)6RykHJqVnzH5MN!MHQ@g8Y%m^jTzU2tdwgS;3akuc5A(hi8E3YQw<@xG
z?Gf+)QXGQiFu;3cvzfNQFU9<sY<3sVs>T|rul~#*tHz4hTHdZY>*(%#k9_dIUE?dO
zv#RbohJV~Oex^FR&voH$8K2E-)xe_cdc%AD>c%H)FfUUl{lv%Qu;=jZZ{)B#epXzJ
zHow(4D$Ar0RQ^1NRb&Tv-<qs>M!yW|5L)e^$geVir+2>bSZ>uo1v2R7+lw0TJvG@>
z^;%=zp%$ylzSuaq7V8?3@IV9f8Y@J_tvjwh)S2025=c=+exn{67~3O=py~EUK$=ZO
zqehDZX&Xn>XFVCK%)e~F8o1X#FIe7rUeP;rj^R}rvS{~s88*QP>qcP@%CL?yY~z%M
zY>bV)%p;nxch%cD8#gs!zcUuc*WbfhM!3$RjCbZF@TjJ2UYmWxq0qK1^n6XW5)N*q
zR@HtMICpC7IU+NgoTr${e-m6^5pM9F;QCr}ofyuqG-U~{P2`;(`~Gn5ZHA9)Z9X5^
zjLl<bd2usVg`MJ+o3jdPuY8`@oRz<8>M4}?^ha)d{Gl&R`Nfy|N3$+%XEr&2hM?I)
z_fGw)S?7DF{@Sclv#GZ`=gzFQ6~P_bR{j&;qE@v1<i>T)+0MxK^4JnJIAZX?$CO70
z4<4ipY@iIRSx*^QyOuJrUL9q417$e8!{HqcZ-3DKphNpSJ0yRoGHhty8iSu6H8OwH
zkbc9e_f@ho?|phipFsm3OQ(>`?DU+<^tI#t5<{;(L;LmWJNT&~eewrBI;fwF5r6sO
z2U)|Qjt_J{+$RQI1=<U)vf($wiDwL4??5Ot8t%0iNeTZW*Bs$lM%-rb9)-IO=S3K0
zKWK2@K7)GUYwF0}P^+CT7Yf~1Arxv}J``F2_Z$2#!u^c;OX2ZG+-1b=;gug^Rh!u>
zg+ht{qPtpA@-75@2W}7CiH-9gVn0O&haijR;HJPWfm;o?39e)1zjyNxz8mfk+)211
zxa)8VKCOSmA08G7p7_7#3x>)gFbD1~xLmkSaN!Ai!#@aaB-|vpIdBW%R={n5+W~hF
z?ik!Ra981O!)YkL09-m;He3U^mT-A+J>Ukw<(CVFLgN5tz%77V4!0g|E8IS~BXDQo
zuE5=Zi@*!;!zIII!PS9l3fC5{E8JsnL*Sl+n*uivZVB9KxJ_`o;SRx_ge!u(9>gC7
zZ#U9-%jH3H;O>IUh3f>@8*UKXNVrLGbKn-jt$^DAw*&4V+%dRs;I6{mhSTtx190hZ
z*>DZuTEgYQ^?(}y7tF_>ad0!>7QiisTMxGtZXetcxU+Cq;BLT0pw9W>lHs!8>cBOH
zYYW#E?lHI_aL>U_ftv@n1a39lCb->jhu}`a6;%oaL)QV6ER+CTJY0FW9JssSa^X6`
z^@bY+Hxh0V+#I-ta4X<8!0muL2=^u2X}Is;uEO1fQ&Ex2zy;t^;3~q^fNKEPtg;Os
z7$4uC)xUReb||#;UvyKzNACNoq0pyr4&Y3<#&DfCvd5W^1z&tP6iR9y3cUx{p#=&M
zZgNZTwF-r{!F6pN3jG2%s|{M4ToepkuX{tGKj7xyhcduq<^Wv(wxJNi<YysV{Rcv!
zFW{bPkGGo_3N3@XyF(~+94`OCP{`LY6j}+_s#B;+=xir6S)D_nxQFo7!?o>#f`OaR
z6$Q}^Zv(Dl_fY6Z{{8@#RHtvxP-rdOThO~Nri+B90}qBHoc4%}Bm5lPd^o+C8qd=Q
zvaP|slaLCo`@|AwhW#UI@|khuH}StggI30rxU}$pL*V~NneG$OvQwr7aQonH!Byu!
zJi&en+BmAnOXvXL2%j}5Vbfhg*w04zEzsF-ghH>vy#-eYw;k>P+_1Os!NN_4<8aI1
z*1`2%h0o+|@WQ37zQa|yBOrC<9g(3aVg8#NUl_y=tHEO!!D8u1X}i8S6p6Kn)$bIC
zt|RP?cZ)-H;NMhO9O?v`xS=?d585Ae9_W?r#i320zw9Uuodk{ESsc0zdJkx_rYJ9g
z-UWIEv<GPNuHw*hpuIsCf?fsPp~2ERes^)`ECPCbTpWsUDau*U@}OURf^i3Eo6m|v
z13-_0P63VovN*H?bQ9=4(1yo~LsvjwJdOu&E6VV%i$mF<=S~!d+Je4*vN$vdwAtz6
z&<xP#XNp6sLGQ)*>Yy8gx;__*Lst>-F{r<cqEz}8PY&7|v=iu(i_jdj#&^&hbZ`+g
z2fg)Uap)V+r+$Lskx<|&6bEf`tvJ*YH2&w}&|{!2KqrCj2VD;OH3rYSL2cKOJ_yhs
zAi|?4oqvS@&~>0KK`(+n272%}2mtl`4gsKbZ$JR(d!XNd#@|GGEJUvYEf4zQEu;rs
z@F&uPPRE#e5@;ukmzRTH0o@JykcRs84FHQoLyu+Zt{$|<ps8N;9H8An9|Mi>p&bVG
z`O#s3eha!A^qXk(K%h7AJw*5wWj#ha<v|aCwggR%MS9T2pp!rcf-VPrAqD9{1F4~4
z=o^3zX=vc06eSL$i)_$C=+N^(sm~n(+5|n(JkSv^C2RuSl!G1x^zNGI`aqwmjczYm
zQI0i0#-LRjp}PZ}hBk2q=p3|x>p?f6aXSKf2o2s1&`P~9AV|i_`prktt%26)2aQ2D
zKaLh3w9S*~%0P!ajUET|4CocmDTC321yJ-upfITS88o<{nM2WYfo>j#j6u&0M|#l2
zkw_1!jz)UWzGIL+R#C<TpN9Yd8x&~^nmG;vKo^dO0MO4SKmcel=t0nWXlky2b_0!!
zQ<S-&*`V)%wgtTiIta8W+Qk{5`$1QOx?ezg(C(mDK$n9?mW8GFCO|eo`xjB<p#4FI
zfW}QmzYE$MbOY#N&?BHffL;fEa~k^Zc(fbS(YJzr3ECC(C(x0g6=!0A0lExy6X<o&
zW1!wyD0<M*vynal-~UB`2G~+iFb4ua%NIZZXr;Lj0J<4;6KE0WF;Jfl0icIK;}h{2
zf;IqscplP&R-KRZpyNOnfSv~31lkZS?J-aedIOYN;P@nb|CP`*H%P*hgLVad19T*4
zG3Wx&gqJZq0^JXK7S#C)Mli{!3!v$scfE?b0~%O}kqhWEpyNREu&HPX=nBvspyL)H
zJ?JJ-B?Yf+F}{`{z<o<lYeB0mMdbsX3_1z4`7(Sipbx!)&jqv<+WT)n-vNzCMUjG*
z2c3;(y(MVUDx?Q(3OWh20CYL%74#9iLEl`1^q{vuBhnP*qqX?{%LDXZ2LYgK*5k7Q
zed-<5e$bS6G3ElDzXAOm=)k{W5C_`fJ$$a|in3)R28Ez|Hlgx?c6lF_543PIDj#Ul
z7F0ga)}RMLYi~v61GR5M<;%d=wk`B%C>vlU0@{L>`v3w!Uj>~5+G-~%ALwJCM?hcP
zMKch59UtS}Wh%;%gEWy)l=lyz=s}Y|N6~}cbr??$x*GHfuP}m@OIW|MI8;NyucZ?W
z4yqYk9k>R(&j?nD4dhcturyeu-Ud+@t>*hjuvB&bYX1EQmdUcY=UG;c`FPD|!Q|x~
zh$Qi6h&;#(K$=f^zc`dbf}45$FRCp(jwd6X=+zXwaAi3|V~qHg;qgHkpN_EIh~N4?
z|M^*DmBnL6LW7sL@OmTR&Ewt3yI}_(4X^s*ZoX(F6g&D6{{WP=;inJ{v(TT!Rdj%-
zjzXeVyxAy(4&{A_G~?qzY%@PE<~63W1p7SL$E)+52y3?HaB+wsb4zLUw$O@{J_5E`
zM~Xwv@OYcbh=G*8j`-m`V>HTTAa6Aq*}rp)_a6-<FCXXAMnlQ(kMotFWkeCcc$|Eq
znBNLQgWd2<=bs~uy$J9v{wu*qtbqG?!Wfoh&j#$n8xm{_*qwI+bPNK#_6;9Bh9x>@
z0I&YGn75}VS`E)e{ywoE1We_}30?v8@|y%BF`y~S6P^Ri2JFro5^M`tnRg>N2(T|7
zMQ{e-X#O(6)qqX;`veaH_Tk3~UI84)Zvr}Kz_kB+zH$UK$_9?ST+C-rfktiN3G!~w
zgMAQSBR-1Y48UyuGN5BMVCW~l`FWOTKM1^nA1970fa&}u!AR7eCwRhGFlPh)dYd;I
z3+A@K*}NNq?SlZn;G>9R2H=my{1xI@4Lp*+PaFpU`|{%iuK*_So5UQ6(b5f-Ck9Dt
z;2&%u{xAxaMqiV7w;)&s0R|)ZkCP#92Jm|RGJ@@^0oU>O2_6L8#*Y)c0tf>r!AOjw
zvUtKcyv`iJX1oc(PJrimAHWJD0Y^rmp}nJ4b+l^L0>rQ9Z&0eOfJ^zu1kVD#$A2Ig
zff3gc9yK1Bl?QCZYmP@~E?_I(ncyJ68GIDMIe=UEYk-wE0RGktQ#aH%tG2h9VVf9X
z`@@DRO*Q%$c#iRJDdlazliW1{FdZYbL%bTnmNaVP9S9Bpe1{JwI0NuQ{xZS!fK~W5
zf=2*#er^KvybidKvxzLJLcjw9e)mx5ZDePup)R*Rx;lu@=gq)s?*#Y_??W&ja5EoI
za30`VzLekwz>0h)!6Sgx_&I{t0b6r62{3@6otI}2tOMAdHzU{yunq4+FduLoA5U-|
zAmkF<0I2bu1djkF@pA;P16JYe1;7A?e9d_V!8(9wZ3uP(?8*BO%m;jwk0&?}a426&
za0B3KzLVe)z&L)6;B~-y9Cm8RMZ?^mXArCdIEObQ*a`3>-seS@R&gZY?-+q$_)$`N
z%_iD9p!}$jS%CN-pXMLTVsWl?_&32nmVbn#_LG3i`6UQ++$Jf5`K-yXw5CsH5sqYx
zAg>MPRVK4kdsE;SdArHTxHn)Ve~REZz~Ou*!6kr$`5J;d1n(yV&jMcHKL9!uj4K1f
zNqnN6#-v_eZ3;M=0(R%^2=)eilRrgp9AHg8li(7-<$MjGV+Y{mk$lz^mgqPO{KrWC
zBd}e;$W!B<so+ir^zmv0Y23P=w<Fjaa0`D5&@m41)+jz}D$*?hUd7iC#}2@={1bv_
z0aN)8#H?UQ+HDN~l$g_jxd^s51^j}yn+A^FfZvVbv!<cbaqy=QWM6`y3VaR09e_Rg
zC(}^S-vD;z*8qbW#;NC@4~3fGRaljMq^RqnTg*ay2=T|l<JH5~$B>KojblThNA8I4
zYQ+yg{B^|tlk`Dl3K&*nVExYotU&xF#Gkn%gRiX&_91=+2IO7ui0^2{7a{&E;{UM%
zmGH7K(q1qg!^?01!$f+~hh`yuJ+C_h<<=H(8t*m(WjzS6cmf|igZeq(ofFYMKgSXr
ztKqpdk#9zX{UGp5{5bgSR{*E+o0OD>^xdZO2dK8tsQwM!a3(m~0`BA82o3^l!AB9C
z0l1F84Cq)5xM7BD?+*fh%a0Ss6+m=H#1R>fHfR=Kiz?#C2L5RlZ!`<Jv;}^dcbi3`
z0TcPCS$LW`fKB*o6uKVp6yHYh5a3h%6v3;2AMrm4`Z1Uv#ZzVj<^ZD4AeaX@oj)=g
z!tw!!^6?Zp5AXtCN^k>U8sACq2;k%V9Kq{?m(2kTV32<g&j4&y2k;t(=~cqtLqGW*
zsNv{@_*;k{6CSUQuwHaN;veGUN$Nbnb$sa@=tZ*%8~+H<aT0LqV*U!cRQqk<Dcn^6
z=Hw)LGnEU#+!XLR-j3j7fOGgWfEA_ycEB*a?;RQU6d9)@Yz5-y@xM{3gCf=O0@lJF
zfX<sXX3S-2Wq8qRtbsbE1<zc>PG>GaGekd(BE)Z`0nqo0U%H!TF2=gm;~U2>W{YiP
z%ZuQ*``aS*JXLd<Cl-~0r7?P>Eiz~xRWwp7)MwLAHJs@;k1mQx{4v9+uQhoo&OFLU
zn0_W722_HN_~~aHZ462u{+f*R93;?u9`mT9$!PLnXsVD<({CPqEX{`zqTnN$^fQk_
zN+0q!1yDJXKvP5WY@}o?;loHs@R<slXC+JXVLT%q!jxwooxFqZZul?`5saol^DN~Z
zjPPKHp`c&06vWv|SZgZ;&9ju|*-3F$5`5;-Nb@M9dGygd>S!KqG*2>`Cl}3=iss2g
z^CY5q@X$PHI8GiEj8t|QCkAnH5DLWxbBse?=D|SoAfS2h&pha79_%yE@tNoL%yW9?
zxjge6o_XxfJZ5Jet22+$8OP@Cw~on~$KuRmaOSZ$^O&1F)}|=tDK_)ent4i1dx}q6
zj)rD79;>W=H6kKTRmM`AkJ3fE&_xjCZVl0KM)dwVW^}V&GCCnLEc(q{GrIeeGP+l6
zSoGe9&FJ^X$>{nKW^}Bo40zOxzB)-pw?nL{+2R3aY?BvcZ2zas#8CXDSIy{UKg;MR
z@+i9O5Y&8GNj3HsK9fk=;o*$n>zA{*o+{HW!mFyzW%%OM2<N9rt7^`Vi7-czh_gQn
zpY1d;R1Q!(7ZG6}_;kKvyG>kG;u=$Q7h=s$m_R|A{YQLuwsd~ZuEw_b2{F#sWcVct
zKMP5=#26}HTQ@}7l43@PXy<Mahqjy|it#5RG4KT8Oy2$gtM1ikt=XOswUxrY;?KOr
zD%?#rM^%d$f+uthL}TELAZ_gPz4^$=EjB#42LLkn2vSh75tIF8TYFOE06+2;s~v0z
z?6)uTp9J+DhjRAi34|5zmo?#eBe^a-8WbA`Y9ns@o3;%gJ{8Pa_HxW$7sCC+8X%@T
zi$0Gi#s3TGQGrE$Mjrn;l2nnENkLq^U&yV*%FIVxdQgcXIrc1Oqhj;D3QxTK6!VX<
zgq}8q3NdGx%MM1rzcnR0!=lI+P@*WI{VcQ5!5-Hvl!z=0hr>G+G0~gBrLgFD#DZj_
z92kpksltG#vgq;Pu(9axktzZ{u-aL4Gx!`V`UDa<S#%6oG#33C;#@46I$bx5ZVg`<
z7QG(QB3bkRuy|N>dk`;+UI7*#i>6)Zegwi7#iBz<5Y3{iA~1$U$0A)Yz@p0|G?qmd
zK({y+y$rsxEV?5i<5_flBurq@``}At(f!~{V$nY!i)0o(AAu>*7lElPx(kG+K~W@6
zXNrxAz){0C1wuUwfa4uC{YObPdNqz(;>{@DCm%+<qjnjNK+W3{?Z2ar>j!xJUJMT5
z@sTH>*hqw<u5CU&BMt{DS&sVt3JCKqMbqtQ;G;rTy!3_~4aEzJ@G89LN|soOxE*)d
zE>Oz%@TY;}ZvQKkatLL8kH}i_7V*U^SwgN*u9;9S-uommv=9vGUb5pjTDoo`n=CIT
zbBd#NSrU_js!592NVcPmttN1w+DofgQoZIVA7&41LWs+Dc0B~(7mq-N-EdsY5niR5
zBnn%I35t@?N97$>vCJT&wAUSb4X!kc>jB9{v6U%>S};IKI)W_N1>X{o9W^AYusZ>=
zg-a*}eID#WE&4ia1>=Ir{rke(o}z38bAn}QFE{%ph6LCOmf$i3helsj(#!mhRV+h=
zRw=7lin=_4-?f@`W9RrwtFh5*EZ@JHWoPZile6wo)XKPQJB`!FiTO_rQP{(7(e@M!
zR+6f!Jar9Ak9vo6?T|w+Of49sWSr#f*FZF~czO-167@T2a`yw3LDYhl2}>jS+iO^5
zw`e@4dGIaplWSOF@Lz2>$D&H9S;^=*tVVP&@Lx2dvk+}HqR>^Xmed?Ub`;6m6vZ59
zQ`;&|;nD2jjcQ-Sn~mxOA;xG_*Hgqes1lJ75G}9Kz*5VL26pFK)`oq>UF%rQ`>0LT
zXakQu)jx>};UBfHRG0pueVvYIw6Bxag|)BL@|f+bXobx7l?E8pzHX&NM*DgdxTJl3
z21%{<H5Hzc_LW+vlJ>P3l9jZtOA!~|zE(lXlJ<3@B^2$e6l%7w^zKXASMr6muVYEd
zVN`^8`(3L4PfJP@)sQk51!%upbx~vQ_XlfYSZBXSbrEO05=~DViK-XV9NH;SB*@-W
zwe3diovn5vUVT8e+5y>W2V|=qK&y>f5Ri>_KsMR|*=Pr3qaBcqb^whwJ|z~Atu{?N
z&}s){s~wQ7c0jh;0oiH?WUC#Jt#&}R+5y>W2V|=qpjJD;0<zH#$VNLL8|{E>v;(ry
z4p5^VOk{z6$Tx`vWUC#Jt#)8M0#jK)w%UPGt#$%R$ZE9*pd`#zn;s0UHc9}E_A+3r
z(T<|xHXCj7$VNLzt#(C7uv+c+NSx7XQz2WeHoa)H+W0vdN!hVO1`ksljiX2dzhX05
z@_dqJw&Zj+%xuX?AGGAq-EmKhP%gG#@af0kOC+CPK18!9dI+m^rx>esr#fS`?j)L8
zcT(7F-FE@IuHi$Ly}PrFcNe(aU(!6oO@=V$zR!p1;ieUFo7+oAAtT(a@Kkp9<Cp<C
z+%>`Kbgu)}+z+Dmx!gtQ!QAdx{4L|oMQx3Ae}Yk?$Gr!FyzchM%;$DOg5TX9LZjSU
zkSbcS2`$RmnjrtUqZ;&P&I<l0$Q6a_tQbq0VGWte&{;{8q2^7ghupIgh%Fr*<bgs~
zE=Y-;RcxPv-LoG#q&u_y14s__8P00*v+~+etj?Ml6yf)dgbL2u(fRPiqlBIYb!gN~
zI5aw{Xd^MsIyO4OXxoEF(j4(~fjxxdwV-wc9`Ezz5i!ma+)ah&ErMp+co)^22=8?S
zX%qbP2Bgl~MDHTxiAr!0C80SJ&XPF7>Dr4L9Tb(~CVRr9O$nDaHC);>DNU4AP@C?f
zZ2|F$?Jm3nO-rIPs2;*O+DjUZ;Jr8TDm3mTwH0p{YN22D)I^$eZ%5b{wO4&B;mJ~L
zO;D7YE8#g3Z~!l^fi_F~z!ES!TtI<$t`M*)h<Htx61+3%!Sy&2m!sHXNt`=zKZzrp
zr7hAzmbk^97ll5zGQqV}2#A;Zye>TH7~A7LXk`-1AgzaRmiC5L8y@*UZwh^aink6u
z-ioU0Ng>6SM!7~N+(U^7XKAan$E`%GjfbdAYOnR3mudQu&yzZg(h$zlHfk%ZG@A@f
zE7H?#4iq6xyjLgB7T@`xlrVwbt2c22Ng$lAy`!D9B)n@#5XHSgJ}cfArST;cQ5wQo
z+6P(+id{b5b|cO2Dd5^E-gvzC{c`Z^5-Q+PkD^S1nm?{G5_!mzqkW`3X-U{)Na#&Z
zx6dfyWynqY#Q7ts?H!B1+9xsO!Rx1OE?QK=vm}jhmUc*^H6N+Z=i$;08`6GHK?|WB
z@x{?2E4CgaAv$>zNg$k~9o2rYBpfr!UOds)GL1Jx`kW9i0xB${R~eIZlLQdX(N1fP
z@nBMgGlmLJ5!X5KMZ^ca-y&W+mrP$<x_3BzuIEK*LEIFo>w&~J;P4R6(!SLOTjDMn
z`ec*1BD2y>AYW|!7)nDpN4u=8x6)iO($I-<?Z@b3FP=Z$dj$Gw*UVhE(|awOOe<I(
z!dcpN?HfzNuZ9FsYkxO$JwtlOm!)>sM>t)p$Fw9Ap<jHw^_hHhF*DQ}GWqO^>xDAN
zUpD4iqL&&EcYTOZ+#KH)b6<oc)%^?p+T0)E`6JxZ@I-cZceD-;cNJ*ubT^{sb-xE5
zmwPHg+-~|>%D9t(Bi#|;^tkJwf_UBQ@ytFq#}oP8Ymq9-o$SB}A=+IGPmFsJau2vG
zfHl_bLr9#PHd>W+A4LMRPA?!@YiOfqa?M3<hSrU}X~@F;IsPbaTK{A20bo(x&k3z>
z;5j1PS<uMt{u0>X?t|xWx?2Kk?u${#-=)|{o_4S85E6QRqU^N${j?e<Th+GFl!fAL
zR2^LHj8?T5HP{b`&QyzUO3h$<8N<^2@iFAjGyJLkcstdj4u(I)AFo56_Mq?wBUrLO
zehn$m(O^hIJ5O3@oorRX7)_e&g-cKp%ah=TqPD{4YK@0A3Zc6<62<2J9)FlSUOfIa
z6n2EW0(i7QL%a%w1u8=(%n+`7klIMt-y5Wc+&vKmq_|Is^xvasV5}f6?FkzRb~Qz`
zkz$Z&xZR7Pu;SJc&fIOlsk*81*xZAGBiwsMdAEfM4z~y5obESCn!6rSx!h||8g9i#
zLbXx6*A~_*=3Z#19q{|1VajL<KN!P5-@>ZoT|`6!m)k!FG2TAtVqIkdgca`;NOVOS
z-P#GTxje$-_g0`>q7q&LTf8?FHOUnnvk;zibm{#5tt>Txq`G2lbr6_X4L!Tt5ldt6
zL<gU+mF2|0ifFtQ>R(*8L&l6Q{aGL1zm;XgtUxf+ZB+(9vaMiKFmsrj7jMN5h8zb^
z+s5LUo7daMQYGJPTRGyRX==I>%^%;!GU_bEA{UNsWK)*5f~#XQ=(!NkoF0s(rx~O)
z0v;x<Z3RVRGgt7f+gO8O4E2n*f(6uQ#L&wcYI80{Vbtx2Kllxh1hd}PPzD(yqoKBn
zl#yDHmq8U6NovwiQ!QwlK|>Ju@1a+x7UX8mMRshMtqh4IjVm_6n_>Z56b(L7@)SPo
z0~TN__>>P=g{*R<W4tZl74WD9U6o4P@?`ES4JA?#k=eq-zx;ru$9za%W-Xg&WksQ3
zW~*&y<<+@fUVS@DPyDDX7#_5xXF><HpebZHM59;n2R>js%Zw7Gep_uKOS5ZMA%Ar{
zE2oKME?a=_*^W2hjpE;JXBqK=`CGNBWX{d3SrNjE)F__5gCzuM^v$lSF*NK^3wmb?
z89%E5nKjC=;u};DTh!Pr&=GCr^DIW8(T^=`7K5@CS!_`oTeZN4LS!GP(UgV?lR74L
zL=`;~3cpf(JDI*8-?W28Mh(Nq!S<{1)a{TGGx?W0SVrIy)s3%B-MT`TH(lJllVzaT
zvv;x@!8T;cC{$hT#5;UUsd$z0c~Om~p~$`W$vg&Gx+XxL)b&NRj#(VEk(Cu#s%7pX
zUFMqp-kI0v)#|3dYo>U4^Huu1?uW9d7_U+h4pF122)o}aGyO>t6wqud(;;eQGt*Zn
zlV?;h*hGDSP+nmdOG}(WpVJssRBe*2R6IbX-(HR8J$JFB2Sq`*SH<T><*H^OHcu7Z
zKMJnGpvPfPQN@r3$unt)&w8pp`ub7qneRbEoLdupD^=5quSM|#yI4k0$c<F1Sub!U
zy+DsyvTZXvlizEm%u_0Q@lCOtEM^sKb5~l*r(I$_G=<8NzRBvzhwhr$2JJQbgZU|v
z-ZBl~aB2>{Hj0>@)*;4;6>oU?=nut9UI?P1Y_@;M%ESBvb}R)_F;l~kxiSs`3$S_Y
z_J=GXb6^^L%UF6-d^=R6Li!4pMy&+p_JNz%-_0rn1>XlOnfS!VM`LETizU)`jgKue
zjnw*xCCP-jO1ab)^0_t{6)Cef)v_;GB8}Q@1-Hk_yiUj@WJAlO?cVGZOKmMOSrE)z
zP620;NmG$#Nig$adez^WdaMX$3O$OX9=3w@Xx1EJ!r&0|j*6rX8_A-15_FR<Y$U5;
zR;YVPrBQMyLvNafsca0Dtt<^1CgSLySy3`)P_-J%d^<#GQPI;-w_+`N_72QPeb34!
z^0A+>zMqNl=38yqfr+{-3Q*+L$;>M^lSaj?vzb?3=7-dSbYYPslnVG1eQ{k`B)|C)
zOVPGdY;Wf0se53{qd_zq!eVF)jJF1rKBbBV>oq;ehK5q5-_T9bk1cGEMQT~me6ld8
zL&*G!nrc5wq*z-4%61hMM?k75bf(D_i#2u5%Unx3$FXXnz^L>yAEOeAXQGF<6)X>C
zb|#htvxu8k85zaD*@MPf)P|ZYk=`}FNqTJrtG?>tse4)ay`p3JqbgMvGICbCKyt>3
z=jmKWKF0}|66nVk{)QFrZ1FXY6AiYl;KtZA@$rrK@yUBxs#DbK$w_=QJaLyu)*Pd%
zHce|vk2yDmpG91oKj;yc7@f?LU>c)hUn+R1Owu+}{K`aHW2XmBJ4c1KHcd?;|CC@F
z8Bf@{RNiVIOLI1&+Il#dKWTYRCG&!PEXnyYwU1Y0dEq{m>D)r!=)*DmBx2IVV?12f
zsG?~TDgPdR4f64QrlHR(`!TB)Lqm7=jE9zXM2lDLX+Q7sF-w<Kylq7zdG>9p8EqSo
znFz+<G%^dYc4Cl2Em@79$luCywWcgdqeViACc)GuOSDyaDQkd~)vBJ9^_Wssp<=u{
zlDd%{hJYOY+sDis6uI7ARdNnea>mmG*7rPNa6Ke*LpEcqZ0Z|5?Et0b5UN8pJuwD%
z7mHgeRMX;AdZVx-6gL?;<l^At_!6BFXaw?&JZ2k-l_(Uze{r=?8nqSsROF`y?=))D
z1DHnb5frZ(M(sHi5w=q3q$8;IK=e+8JLz<)Jw9roz;fkq1>r|2Jjrt$SdEAXTR_xY
z=rhF-8zw`CgF0~6W{fiw*G>Fou4hp;s_O*)+FW$@Ai|Z81a{Z``0H>r0guzQ1mT+N
z68^ee2l3bK>WaT*T)hw*sc8F&Ni0!15*>e|42}rVZShxiJ%hgyuI>Rc*}6D9epd`+
zyIt!bBhgh0ILY+_Va2@*B;HZUPm2|0=v#MW1?ct}r3{&|9F<+407sOe;ijXC>sxrV
zGBjUuRE^pK52iOH!I5nvEo>Fg8aisk`Y=d!0|&9V)kbRqpA?<z9RRFEzJ|Y=%pgx>
zkgjM?LM!8u>Iyd33(#C~Rl{HA`VN0p*Gl}gDK=ttG_jFfkLGA<pH3Oj;SB==Xf}k|
zf)$CgsXZSaZ@l9^`*r|ded28Eq9^uUlbCGJil5T#hl^68Gbp^HhxkP>Ez$@>d!!N|
z7G`sN1>&-$)15;2#X6CK#oMm|TXi1wU;Nm@2k?Q!<<|s9I%$ihA}+rcd{v~cciBRG
z!#%;|vMF?l5dHjAEh$W798l~eM9D=%5}~w5gJyhck6=9FM6*(|(SQ;w%I8r^um9?&
z_8(rDuYq-=-~pEK&)4F6pkV%Dt*Abtu~xLhp_Z)0(}sF;t%$I-7EktZS}USOeRHj7
zA#llBQ3~FZwN|vB(h7^q->=1!p|@nMXg(Oz!`9-zBB9n=d|yi_){3N1bFJtv*W$&B
zleJd#wj~8?MN*2nR&<l}^s6=f-1P}d4w|b%v_gF6s?Z)(rvJdI&|fbK1=)XlRp_r5
zg@XTNRp=uWhqWpcz{g{*3Vnv+vsQ&Tu(c}m0~M^fDny==rTi~Yl-8oqqa@8(6xtJ{
zFSgWLK0>f6BxIYbLZks&Qe#yp9X^Lfa>R;*(-A)oSgtrYgBmT|2xFFWoaa-FnB;<k
zbG+DWAQv2*6Z}tuOY;WBD#=9e9<(mVfL0lt&V)}%oLF&izNn?3)0W~Uhl`sME^ewJ
zPDq<3rOCCK={`DH0Fxe>*PW3Gl_5=<+MTPk4t6wv!d&ZI?IpDpFWK6iYkkMSovzr(
zzV7s-K0=9vt=+j%n@jqTq0_m^L+fLTmu&6M&4JUDk+8Kpx0nLRRPOX8EFuBIZ0`I(
zJ8TKq?g>f>G<|UH6naa$xpS8g2NlRv?)1meZIaS#?)*s0K;tS^*kh<ba|Gu;-xop!
znjknoaehP3Ak5~@Ph!Ypn9ZG03DqD#n9YM(&O_RxmblNu#T_=p3FVIXBGGk1A2O9Y
zqmyYJN}A1`N3~^^fMZ56iZox#G{S7|JRyq2Fq=DLl4x1Zvn+^m%yFL9u2~Y!7%Gt6
z+<8vC*LYzzcb-e8IwQ^I&hw(M470g2koYHw6J~Sgw^{|1hAf|phCXCAcNU2UN+(M+
zd}4GGbS8SKj{bjbi8c+<!GFaP?QCeHCknGfI~#i|<AwhFmT1!u9dzDn`x>&PCE9tv
ze>23&udQt~Wg#um&UVJvMk6cd17g#T7Dtw7XL}g~OLQDrqMdn$Kh+;cmS|@O!=K`h
zBTKaNLBpTykAorFuQ)pz0n!r9D<5VxyO4?2dBE=gi6;}S^I!~BKeRgZ@i@dc=xd5`
zMZEJa=D#0N{$d)QHDL+lQT*?c?{1dV1wPI1pb^MDERnx+m{ko@I%iX6i$+}70<%`e
zOH;VNSYXDu=0C8$-1(m@Fl*&(&q1RExxlPd@aI7r(THgkV@Webw8mPcC~A$3wc4x%
z;-dBC^+#B_x|CL{V)GzOt}koZ{<laBtuJfUWLGTKm$jN16hZ6DT>Fxx25B8xt798V
zNo%2m{4j+7KuO6^>nbBYH^uua%GDK_L=iMN`3TfT+%Aueu;(+xH+A{^5913HnYyBl
zOnt-^okD{FzciG`#1L1yw=KoQ#fb(l%X^k`ND!@dj`s@R@+C{_NK#!Xwh(eiGEC?s
zCyDBZ+Z9VVc^Y`wgO1O7qM+~_DhXzepCXf#Pa9Hf1;QBGrfdyx{Fj47*Xxuh(bJ+U
z&-;qS2Db`tl_TIHJ4f1JXvUJtUPQg6ty<~d!bVCzI=V-{w4cj^A<a&;jOP65zZnc8
zO@`ehF+HBT2AF2j7j+ZqlnvBx;Fl&0jOEKx<yH%Vxfz=bhI{cy^jn0i(}aPiQan8^
zY){zo_ppqtN1Zo*X%i`zhKbaPlJzA$-C*c1<CQd80A@AQs8^GwFN$zzlx=1zJ)}MQ
zsWO-inM3rZM)quBim>b3Yf~B1`aue(yzFhH|LoWlv3y|fL$8vohH0Xt9dQr`{~YwM
z$1v}RP+C#VlvD2@GNk!HvtClY1Uw`CqWU1>zd7~(FU$x2dT%a`-Tz`f(1ObJ0Iz;L
zZ1311gqiaJ!q$9%)=}t_qy4_-d|(A|$$X%)HR#6PTpHE?d-DO>w^%YC7;Fi}d_W5Q
zm*xZYkgjC!*xxKEm=8!Pe?K4S^L5yK;5nqYb3Q<W*#B$i1D~TftoZ<qzyFu!1GL56
znh(&R%A5~;L3^J|&j+~YBrM0q*gqTG*oB0@=GcD*ur>Clk-Ite?}*mrACLV<gUi?;
zHPK7v>XM=V*Cfpx`qN<D82Sf2Vd6@S{lmmflj6*={{_f4HXAv$q`D9%Hyb%$(w-pM
zVi?c8q_x~^<b2sP1Zm`EBj>BWOYmTj*+fG_=5!^DAPEQXTn(JFv`v<T+2Iljyq^mR
zWD|GlQi9lQ<kaIxT#npq<a8(QCTU``k#muD(~`E>L(?h6OA8jxr9wcwH%NAA=j+0k
zZp~)wH0l)_hcKI=LA`vU)rLOCWacN*$C}JEq%`JahKBJn%_bvPV>0tA(pZxj2ndn{
z+AQSsCXOZvV&jnW9qn~X!n=k9q3H&xx7;{{8PHlvW6ppsSZTH!X^aUF)dgz;L@FRt
zIROgB{X`PP#v#mrYNBwZ-g^uQ#teu`INoc_fNqfla|T47k{M7F8uW^dLzn;!wWNI>
zF72>U_M}|UdBj%^eHs)pW<X;}g4j5O84&#w2dU37qwI|tkVs?Bfapb(%z(C&0I_ih
z6Cj5EQ3^O?s9;QhsB&Wh6hu<YfXHXffT*-eW<VZDux3DYEpZnOeT*3pl@Gm1nh(Xs
zH={IS<B;>RHo{7C#YjUNhnzn~SH^P(<;EfBHSvKVSK2J(ESo%mB#4be&g<GrOTw>)
z1X_J?{%+LTuz44zUGzQw>(j2_e`W`eIq&)xr(N_wa@rLX(?!g?){@%)_6{I(-i2vb
zF9@=xUH9O%nA0xG;qRth)c*Vj=Ut_zU69_%wiy|RZP;=4_flIZ_v-}ze#4IQ3ETaM
z58JTg93<Ml|I~&Z=P28A$N=Y&A{740c~(wr-NC#t1r^eq7xF{rS$r*PE=c>athpe0
zO6G$3@P*9<6EB3#1#2Mg&beSJMy3Bd=YlUoqmsGcQ_#ko3zBBmT#&{B)?ARdXfBxW
zP03ua3c{?pAYJBV&IQFV%$y5SgqRCH^G(TIa5g11=YnpS_072;H9Xc_kRoVcdLG>7
zT#&Fe7o;7`=3G!_YRm=6W6cGL%a{uW;{w$7TXR9`#W5Ge?7)?rMl0A2klk0v!l6xq
z&!PG8*Jex-lYx`Y(46L`BRCLx;&%cW(T^?chE^+COi^xDBTUn!WHIf#*{qlFuMej1
zncp&3lGv$p+b%ZvVb+zB0|5@Oq&BX~-}#o64T_CEDzlHno5EUpI<1DJ4U9uJHWo##
z8@4@R_58{cl(nMtlSD~tToo*3n4RjQSdw*U)5K%UKtN_L3HZTtWq@SYjZ|!5k)`?%
zHAwX!)@75$1oVd%qlKuva<`3Cb&OPdNZ<8kA@Rombw0G@pV7uB6_ZIaTsIgXA#(>6
z-$l<fL)xR34i(Ux%i_D3-H()j{>fqvd$9@ibR<7>D?PzckIP6s-by{!N`17ROx!hD
zOkIz*rW%F0ZL-)6bhImRVy!=;-T+?pJ618+l|=4~q&1Oq{iVDt>zy9A#O@OXLpq6_
zIQ#CAVxiM3^hCQnON_+LES=)~<`eD8HXrCc!Q6zR=z$zskcJzXb0~O~XS4AlFIqCX
zSu$2tHf3BF%=M|I5`{9Ep5RT-L?dy1EAdNK;x|Q&g!UDO_R9zJJrpGr=p(lMXMRF5
z7kMfhGP+wbiYyt6YMKT6HD$P{1x2A?Q^oF=#iApoI_D6h*UaI>G|toLF}}VC_7Cx4
zj59<GNETZm#x<8O1BJMrxJP=9_LUhM1Ygy&F!af4F|w+ef4Qo}+?b*$f7*4-Mv1|L
z%%4UmnafCGzGtlz#amuteyK#h^)kdRr2M-#3pw;Ms2*2Hql7&~g;-=%Prp?mGBH$^
z>h!Scnb=m=!>nf+7mP%PwMa=lOalAFPx7FnB?XmC4~0DFDQj>}wn}@FCH_IPv@6l-
z=sbjD3#YL<n$g}!2+N!JrHZQFx#Tm8UXE}|l-L{~N^z3ltl%wr%k4Z@`p9G`M)6|{
zzq0aeXT72hg1HSfmsC?KyhZ*-QB?1v3;`!B0Tp41k>%2;mid}Qxio5Se19kgJU?p_
zpmvptA#*;JLbj)SZz*M?C2XiAEZeBJU6X~d>?S3`khX>;t8#sk73Z<+KGqA9O2y@n
zQleQCg5sLqAt=ER)H@@|P$t_@CRNmt@-ec7qh=>X*qm0P6bzeFARZ$ebd@E?)n(d(
z1U%;*yFK#$k3Jm!|F1z~$nek3gVP%Hoi?LqV9xlz_B=Q(sarOq?I?*-HlrZo{|D#6
zpN9m?Xyn1SWEzdAkW1T)5Mr(&#~3FINrRF#<O6hG)1i?Z(~v}mE-gdSQ<MR1_rW4^
zee@mw*pQR}F3XS<g}%1LkTi;<nTDi&mbA$w(t?V!lp!fh+%&HcXBv{qLUxHE=?KXd
zr`BLda@nDrVMrpaEkn|BG(VOhi3S3gHPfjz*pcX9sV8U}lDb$DW_!aV6nO1Ol<qYQ
zNkW2YNFq;(A*nBkGYv@#ENP29X+j^vkVI+ZsWsS<;1MPrV_AGTNiYpbw7emoXtkk_
zVMsCzAY?qks`xQVV;Yj^<b_PL$;j0(B$4sJG9(!Sq#Y@kn1Do<A*q=q;ax+5VMr2s
zTZW`|l*Tk9O|a5zH_{k}Bzk$4A&FE-Hw{T~vq%8hk%BoeBptFO>@g%5h9p^9h9QZj
zhn69UJb0C4Ji=1?NfKuolA=&DvJ^fKmv)$n8~O<4j`+HeG{qJ)3`r?SWEqkkv?Lre
z%HA*}iA1I$iOLZwknsph={-q+X-HaP2{>b@U>K69a$76u<bg?tPM~2aok|PhX!#sV
z>2%?vWk@<=iMwd%V;GX?iSQ7HA?YloF%3yn6J;q}G13@@q(>-?IDiH_QdCgpx-$v6
z#${w6k&keWvj)?;!zWIYIdhnl;TJM$v1lR0{{^M0&0<Dk8VJ=5YgB(Ev#e3GEH!>L
z)G(}3Qgv6bWE%j?QPjx%>*lEcgf%LNn)5$6kA__U^h9^=0+>r$|C`pRAYQj|9u4NG
z7La6_qsrm)FwIev#ow8uQ22&5Do|<{Kp+Og)UaIufl|8w0@f}7j5O&yT7b@@mD&Y>
zfKIkW$T*fXX#^Lil%?}%&WECEz!!EN&Dq^cw$Xof9xYm)M~nXZ^Jvase=jxB|Li;(
z%v&V*PV*ME$p0zx7GLxmt6`e7IzVuOvDJZ}{f)&3Phn^(H>o)P@KQB*&%jo4#Z4DJ
zGxvE+>Q(nP+Fb6g103Pr0)D%j?yz&XBM|O%_d&Sk?gM_8`y9sJZufBTlyOHOJkp(v
zzaIAtgm~R6!Q*q!Mu^`%9ulJ52ZQiLyH6q_#yuS30`B{OW8FU^I?nwDLdv=q0LQy^
zgeSOb;cue59>SB{J@7Z#y%(`5?q$dz)m;sL)7*bTX1e<i#AdjU;BTh8CBn<OFXL}{
zw+nwOxZ5LDMR)!9hj87s`w4im+#`{!vO5t8swh#SSgJBxUldr$7LX56K9<>!JSAqo
z{qTjE{o39LGyA=OxI4{$`Iz|p?=<`U1dS4{Eg&C48`JDZnkiy1g)Ja7n6k`%#6@Pm
z`)@LN#Q?T|j6;}Z_DjUP$~61Y!o6ae{U}0SF`(6st_TlZF#u8cOS?-Q+Hr^xR}5fl
z$hRcYGza!3k;c{#>OM?!U@(bd$R5}L)U*c@w(NnQQc~KG@|Sx<h|Am?5}+R3G6&LF
z%rXbky{}{r%m#I6UwiqWKbWhnVGA6Jz~neoO!gXcTtIt6zpo^L*&-j^r`#Fx8p|RN
zENa*qBG~U5E&O?@zwn)Z;0h374P4CZRJUlRo&MlBDW|U?4rV=m^ADEnx{P|tCNa-3
zo_dSLwG%d#NvyglUs&uWvF3+_puF^=u~NWCrW|3edw~V0j~AARj2rlN*$C#TK9-Na
zWtwS5u&Sm=VSpRK?xG<AY%S@X4Uywbkz#&4irGs<-j7cT|2xg|^YfDDE`yaVoP^d`
z7Rq2&SLQGvg{Bf<Z$)of4dU@L&g08uk1|iTAz+Usfc{;A6!0jkVG0oTxJTJNLI9=T
zP71VUo-fD9gk7jw;>Q+7pj(pZTeEC4y(s?H>~6ACw-W}nilo4KPnD4}9sSp2`mu$b
zkiMKK_47GK@^ZqGb-o#O{777$tTm5O?`Ip*g`d04Qi7Rid)VWi9fPHmC%`~IwlIKB
zM@oCV3P~e_aXDezdb|<E(RP{&!nidcTE5cW72c+2+ai_=@j5EBrwXxEj9XB_Dtt*<
zeIPE*f`K@F(GcWARWky^0s2*-8)w-B9|y+!uRtRmHnA-A0LJkr8k1#Kq~PwJEJNc3
zA}xXzcCj?>Zq$$g<%C7E`&|@8h362%-puz%&$gakPmBEVZ$&H_uUInL8Xv}ha>An7
zwjOm<;syLd3N-KxdP=7H#Y%kCO5DJFf8~16LpQjaqND;eU&wrnLj9iZPa2<QG^!c>
za6uOgII`IN)=Lx?O@DKWk}_!Cq`U?}5y}CSj$!KAhvFks&->#@l%mw9IS_syXCU1j
zrk)Z@PiuPg|Ij^v!T;esfVQJhI3g?Q1XR$L1AhbHx{g2O+|BU^opx13#M_mc_)H=P
z0Na(u6du{r!V!`030!MF!nMe;!b2Ey;?wX%^o{=vzOZWt9p<%z^BpP-OY`fgcic1R
zr7HxD5y*TmE!OxpQ(5|GTNCqz-81NX+4c^?YzOAQY#wcJF7w}ww;4m%3_6!55LRO7
zIzZ<e$sD|5#fZ|-HCWC!ZE;`-h-(I&xMq<4+jp$E69-$F=n^O;mg<)i*9<lRzdx4t
zAUSc(U=Y6eSRuFMn!z}d<HR+Cc_dUEN^s%=t5cRxY(kPkX%mtY7g#+mgwp+0PTXHb
zjPZ(#)Vu;%wmGs^;z*7Y_g5`PP_(#aPpj!~jGSUfHLaG=Oo@4t%qp63&0Y*$v!~T@
zJxuarV4H=<M;>EuzE;<E6YSoSYmTtf@*rgT#5G4gam|rWTyx~RiovMO=f$@l;S;wU
z`NS<pzMA+Toj!5Pk&kXU>g@7~YmR*4nj@dM=Ex_mIr52Xj(p;pBcIrX>T3_7QNFNi
zj$GwzZIFMw9D=wi_>=I;V{n*ok*davJB?gf2^5wdqww9TD)*eas@RSpRkXO%$d&CM
zN{K`lUrm;D4Bctus+mC%{ut~zO}442t%==L$JPXa=G6%FUR?B!S0hkV{wO6W4b>O7
z`z=I}%hr?*a^aVJABA>uEau~EYFv<VW1T8ddbAF5TVkiCUQ}V~)t|v)7whyWWsfEq
zAHgJ`)EOip&rWx^O`0TxDrnTik1cGCq*6>?RVikGl6H|&G<AG3QF3jxxSj7xcAgxe
zCi~sQ*4#A=g4Kc^8Mk<Dgqp71q|h3kO?*g%TDvFRQO0VSJV|18Kvo;*pEQ(W8;DaF
zGzds*Nd6Ru*{FqN8K9+n1?`_yGo=EliL<3+Q}Di+U9BGNPeH0o549TDz&aM0@Md;3
zN&G7%qq%Gf7HTf98U@hKc%;_lq5D5+F8^0sOUHlV+SLCuEaRRm6sKnY(0>g@?tKy-
z`))U3YIte+(nbvSk8ISOdd2`}*}wI-qBfubMO+lSrEyPG3shM9ck*UEU%#gxgC~m8
z$BRqX?BB(aCtb0T2z!x@P6pm-`hE}}oL^q5=a-l2`Q@d0e({Mgzr0k>FE7>e%S-kA
z@>0E^pE@Ha^UJGH{qj;hKdK-u)$_|s_5AWuJ-@tE&o3|4^REDlkNM@Ldj9tCMKM2B
z)@U5;MlFkBetD@L{&g=Jb>^pojd9E`FV*wQOZEK0`bdbQ;PNU|e?Rz=m|tG1=a-l2
z`NtzLmHFkRdj1$lOE0+!wF9JDrtc*viBhI-ME{lL`>s+~q0$*g%k=#ti8IbmQ6ZN$
zee<d=)!Ht(8VnANl9*QRNR)zQ<$eGj)5`rj@ISV4|AFL|mD`4I+#h~~1-2_ndZ+Cw
zh_39ve3{Z;+O9C5yW=t?7_aDA9U8`JO4N&}w3<DJs(lpg=hqx!4}Vl1g=_J@<7GzC
zZg)-Y?T;oCJB!50(~XG1Ph6+Vye?ag8IVC7QRp0ufHKk5C<H8d8~G=0wQR5lWV14X
z=Mjt>VvRl|E`dU8I(#n(xk`0O(5(IfzOv$unwqIp<Y<J;<_qR5ItQs1JQh#02pd{o
z=tW&R{bH8m4}}Gq19%lDiAk7`bU`el((ub{X48P_#}<|q7Z_yMpqEG&7%0Egq7g0i
z+eQ=Zs4Sc4lKZe_+V~1c@&DdL+YTYK2h@sXt09@H%3H4g!DX#u5d9aIwZ1~BtsAd%
zBGuT3#Yp#WGW-&Xz`XIA<|O7h_E{p@ILE$~BEEn+5%Dp3gva46<D%BSgp2V9H(^g8
zoXM9&s$Fp4_C}<7=S8insr3KRMXkpW@fVxz3rW8Ne3(bAokU|!KQ6*<iVA3MwkM3u
z_I#&DjS)9x+uyWNyXnxVY4mN+L^~VDJXA>j+i0Bq_IT!>4Th-xXq*#Rd{+_>O=CfO
zB8&PCR8xG!X-{Ideu(s2w`gC0FPa7{bc=TDl5`l}QaXPyTI{jM_;w)jj*m94(O!ed
zbh+c7ZqZ&yLZ7IDF#G$=UmqWm6uQ|IDx_>-t`79P(c%{EEi8(B0V#7Ub5Sy~`cQx3
zBVqP!>;c<V5^Ws{o@j~2Apohb5RD7E!$jkPZXsHp9-s@l??XC&S{hIHp+!8M1=;mg
z|AP>%Mb|_nus2YR^dr-SFGi|%AOpUJs*4IfUh$<7Ya`V*hop(oJY7diy@`BWjOL|I
z=8=L{Nav3>Z=)r~cqN9v?^Au&apRvM%lCFR1dmlcf`1n>_1nj({vi0Hp6oYDv5!|{
z+rXnl*YSaIyqZWpyi{VfPf%^0;PpRW72@raRR2c!q(U#43Vlr(yr?EqlpkdrB-uVn
zVV|tpXyg2yef9yg7O}F=j+K3Otn9O6WuF}@`|McRXUEDuJ687Dv9imKm0fnM?6PBJ
zmmMp+?AY}|WDv<>WuF}@`|McRXU9HEO0rnlXUEDuJ687Dv9iyOm3?-s?6YHKpB*dv
z>{!`l$I31{wjYWuiN(q;J63ktvE#|kkji4aAg44ITdL3Ak5H@6rj<dn&!$hpI`X^@
z*gEnozGL&qGkHpmJRilAT3t3xlth<Z7T1?kAzOVmRXDo7{6thqpIrgm4vo^7efA5$
zR-e6>gc&Q-A7Sog_1UC=b-Z~PxU4>V3Z`WxE7ONbnz=HaiTRwAHaX}C6F0>bCT^-f
zOx!fD5NEDT&w}idmFembXRS>4CE3QxG-++EOeZ0YwK6>q9;~35M;r!|1aoEj9ZSM&
zZ<vGv?{h+eu`(?rm@CudDOs7`M$*ic>7OlWi#?-+KE}#4r71b$K)!T&p{lb?Vlhcb
z!bCC4`G!^zU9NnhHw}I0({!$=`ie|rtY+5&o3)xvONlbgY9o!Yntf2FF;=tt(-9AA
zIr~*B(I!JxV>$Z^p(>rH!y#`&f^jV3Ey~qA7V()S;9Wz2v6?NO)mqIyL1~QDY}}5D
z-cYK#-AH6CXVV+Ema|C(l#g*RoUXnU%h|M=-P01V#}HtwX3G*bR<n<h0P|P`dGPwN
zf{pzUQ3+3wICxOphqT3(xX;7I9rj6a#&R~sIiybyDwF8sRV09L4vt0qKgGQXcojwV
zH{4x)`{v$G?oB7TS;@ZMBqSsd_T7Xf?7J+&C4>Y5A;Bzwid?`AcX63ghfz>eT)=G<
z6&%5BbpA7nI_{2wj);y63a+@kzf)Cx6EgFE|L^yG@AG{9Jjv}kb<U|%r%s)!?mAU{
zIKtp9rF*rSEohw8Y*Hgc2&?7n&xwPxoL!EVmn!){iJ+FVsYgVXvndf-%_e1mom$PN
z#ly&I_L2y<qe>pNnoSi7qY`R4yM>6H<?P!dM4u}nwVdsyiaX2Ms#LX_eLraI$ZGa6
zq~b+K#A>$aNAb>Tw%`#jR<pxc&dz~3Lw2>CeUij*HdmxWr&1H&DlvrZe=iy%yT=m&
zd6Ltg2>#~>g7E*><5mB+PXzz|KtL7hzM35#>ZdOl{=Z$$ruX@pI9(O1*{^_iWHtLi
zaCKI*sf5UCwsf&-Px~k6|2PU)EoX}?Y-&$d%h@uWX(y}YY?;omlhtyzOsCt)YBgJ?
zozqpZn%x@(pT2DU9aZ)-7@j&tHEewiU#HGdO_b}_iT`2Uy3tSm`+u`+O^i=pwkCJ|
zKQ3G6V_IVUPv@xe=v1~etoG;s1h#2v(VBWRhD~x|ZV!1sw};H$d)hKKnfL#NW$f_(
zgLQ1Iar|Fj#-_FL|I>Bs|GbPH>nvl(Ky7wp_sTNpC*C>9fD&4~bCN+jQl5Buk^#d}
z24AMJuA>afk$L($b_V+U|DWsFH$tLbk#+25NaL(ylVn;F1qEUqo920ub!@`Q#$@b^
zUM#YXT?|-c9s3z#L(fe(%0Nu{opo%=h^%A3j08Q=yog`7hn}_EIN)B3tYcqA_YK+5
zm{$alM;!qm<GoA(qLaU%`(4@E1RQf96E_8s;gk0sy7!BF-+N_{!)x1gM!mnh2pI|D
zX-4zYxvJiPpV+$mGxPb|>3HQz=-wnFm)z7g+{=X(Z>s+$EDKl@A&zFTa&iW|5Kp+4
z-J3!+?!mK<VZDR@(bnaFyR3WjsGClPAko(O1r*4!10C0A@e+t(jl}<0>#0(x!)gJ3
zoHY}C(yRx<D6*GT3bJhLcR3mYFun&_uJtfj<XPW>EZ^D<6$Gsg+!tGyLZA}sE-)&!
z>H+U<%>h-J^@m)1lG)mW|9z~{;8|f!$Nx%eItuG+y#(R<S*wdRt;*Vj|NX5F<PNZg
z6v4R;v|a&=LDp&@4YsaD@k6X1aX-}3@PC+fH6$HweF}mR)_>uCr1dXob(EC>fks;k
z@&62~7MiHGI`F^7ssx8IRvknfYrT$YjI$nxpyRDW_+M*<A<zVC2jCN}iJ6$(OtQ{I
z#$;<SGNxE#@PDc`9xSF=MfgA6dIAN{u=YU2nbzefY?gHl_p_~&_&>)o0Xfr(!~eNf
zGw|nGjeyU$(xA}=)~yitEbDWKvd~IIy%$+;;yz?ugyI)lA3>MlI_qjAmRKKwxZbLT
z0+(7(;=aMsaNlUfqWEQ2EHts)N(VucbvfWGtO=l6X>9|$X6q*iy~>J$R$8pXxNo(-
z!2i|OQb5kOT0qriT?kRytpZfF!}<{Soz_?Qzb0%=hFoi{rTD+j3WD7^)^k8Q*SZz|
z&$C9LHtVft!03GIN~m{(6@qYKYaAdOtpNUSvU2c$vvmZt7g#rd>OyNiioD1gj{+{X
zzJs8bSOx^zVg+!2sr6@YxXii?n3r4OjZobc*25sa(mDvTtE?gvd9^hIkZY_qsBx?H
z916bHnh70TXU)O=_0|HgzQH<$+}~MGfCIO_1OAOxJK#52hau3-){7|e_tqESxy`Bt
z&p%jMsN^lyFcg2QwH12ZZru<@_71BFiQBB1Q0(p2>mb`{jRO1*>khEK)7pgGyDT3H
z-etW6)^}U?<IUYY)<OKg*V+!I_gN3&|8C1bF?*~;{J-Bi3j7DGAMpP{>s|=@khKUE
zc-U$~?jNlS@&6HPbN+CA7TP)i;=R_h`2U!72~Z!mTu{yv)}K+QeO3j?_FL~mlqanZ
zpuj&_7Xkj1W^60t#W`$w_#lAZPmRCAVfb9Qx4r+eX-|dltlrO4$&<+QBD`Ou8p!Zy
z2H|<XG-8qR?SVpE-sAQ~L{kO9ykCpgJ~+V&MSH&y3Ee*u>hYcs3FdF6#7U6|<77i(
z;r-UACU!qTb+-3=`*~uw1NHa*pd285`N8{RfXZ?CKSxEqKV=XWE&7tc29bJC8C!Ah
zdky)v_ZQobK~>h|SK&G}|8~OqO-dEtJ2s3I*1#mASR(W4y73lxWZ#LlR1Ve9{o}yN
zdJ_4Xbr`zVtu!<&vp$AYh89b>UXO0{0+xLQ)$@3<s3F4L=&9ZtttS!#Ev{+lIt&8x
z6_-nkJ(5nU@ae`ZBD@s#k>bTt$7@K%pP$c5@>noTQ%P^Uo<z?hwiZiB-UQvC&)3?o
zf_#@3OCJA90fkr`#V6q8n=5f}e6pTES#~_xsy9vdJ?TOj@wZb$^^&QI`147%8S-u4
z_;`yjbM=I;K{qY_>oDmgPw(|Tl5^ufAk+dq$v~9F;`jtYEtG7Q$KOO|5yS~N$lDnI
z40@BdL{EuDYKxeEczf$9iAY@&e}K4@>)tXQ{Vx7?s!<=Ax;cI}ajB50ZSg}2@V3cY
zDU-LvUr&U6Womo;nL*y1&xVId3*IW-I1H6!&^vyd-$Odc`39q<j_IS3tzM?*{7Min
zAUO`i!r-Y}faE%mB!WZ(lBXcKLtuzF3z^1ouaU2y33s4t>_UBbuz)4RK92h8H|x0s
z@fzFtgaVeAx&g}5Z)dshNFcp=#TA>D$1g5mL&9YcT-RK2Wr*hS8k1MZ?7T)|r90s1
z3Y=d~c6XNPUj4P;qV<#Lc-{XH=nH;F%+50VQ-UIj3OWZ0z!-X=Oh*mnod-qh3(eT!
z226MBD2<OSWKqjsgD1jQbz|tY)puV>*5^i8)7N?>>uR%)WPM|}U@Tk=XwFC$WnB}_
zdn_A(8dLODW9xn4ydTj$^zo6h^3E#adkR^0<;}-s35(^AmM3D@rkf^NlsreM@MF?i
zxs>Ql{#zkSsuEb`X0F6?Bq%rgMI?BfDpzq@fwe^}yP-f;DN<k#I;1|(G^x+a0*hC`
z=5%KIrhXx%+7hXL2<BHHD41DE6bP4+wP$8El?^>o-CinUS>bD`f!=coO%D8*WF=m?
z;#S}G5wQ~Wc+Ztj^@y-~&(+^yCG_|Ym(U|(4Dud^!Rv>e^jRnh>7!11R#9`q5>5Za
zCEmElQv_3CEquLxKnn2&-w<R;V})fLa8=0W+oGE9fJ;<>4p@@ScTlo5wr&gOS!7Jl
zIDi|&CGOAoJ3*Gqiaz7N23dBP-V^B0x=iwMWNnz`{q8ea<xTQO%QG<4=!aZBvMdqf
zHjAV`<Vq(1DQ*+>t5;n<S}&lpuJYVu`L8<wI#0c@gz9sftk0L9NY=;nnes;8_9-k;
z+UISqN?E~U8)OUJ=Bkm_ad?BQ;O$O*P-9`Ace+Gh5S;^!c)S=Dt0TkR?O<LQ4)SBN
ztON2#D{8_<+C47wW7&&>e^U7uIr;RSpAbk`I<6{D=n4R-EBg3_Ryc@ke50(^BOgoB
z!RV;d=vLo$12iM6wb7}TWAq!HYB}9*lOwFt?JktnQl|Mq3Cr#qIx34uRhFGcyEOF6
zT_(9_)$P_$o7YK^uKI{qma@b#!gT6-icr^6ge8s$JC$Y|P7~qsQkFey&_AUJ&X+Co
zMEqs5%cL=ZT0gj1VJw!2TAt{5t6ko%uBsLOOeQj3O8FiCt&}B6A;-IVxTo>19`32u
z5z^7qq|=0)-y5xe^M|tR4UPz+!_IVdcTeSHAr(@B4-ZSkfYPhJ?VcQ`<tlngRMAtS
zN=Kpxl-e?@x<q;cjP!vH#vjAvW|GTTPR$_FK)Njd^ABYC-zj<ZZJB7r0`c92bXUnQ
z7_=j9CfzkO;%4~zGB~U=$c^Vp?;)JWIC3`u$@(nC`kDyq+ljRZ+YPw#$-0R(E!u&k
zkL=Smvg-w$nj)}OxU5834{~Y3#U;Apr|UeeoF)5S&jtfimiaIrQO*kc=2Pb|T_q0B
zbrNNO@*4$o>^1TyOoq5(sQZ!suAEH_mk{2EhP&o{2#2dx{-8fy08H7RJ~Voho1g%w
z{O8EGJY~2=oFs6I(WU9qx9z|nA@QFwlwDy&6>;2888wtkou;JpT}e<Sn!gTD&dA9V
zhd4ZKm~;>+R1_ShuntRPEl(Wi@Qe{hZ&YzGKAwt0@5#JBD3rd$M;z+#ieb`g8j3J0
z`I#T=!vYgT$9cmr>17Tys+DZ`ha{_4)Egqy?>f|rwcrtj6;fE}fIO=LVQ$}&8C+-B
zz0eV_dQ;|J8BxWrU{)Yb?7PnBPtz*+v<(H~h`#HL2{gN;Ft9w~DXupH#00w8pcNNm
zQjD+h_>9*jOFH$NE`8gR7;mL^+l{h^!eSD!D_kJ-)^3cx2=yYLTt?9le*-R}A=DRP
zN{SV;c%gAT5h6Q}9u)LWLk%?h!_vF0H3Bq|rkPG~<{PqXXG4G95)y8c5sw!tc%s?5
zk7)SNN_;augSyvr!}qsWB?+B6N0+{BE@-6K(~UuLtbx>`HKrRAX$?V)B#)3)%`n8n
z2MQ0K`<i5Mx%|=cw!;|pdPiLJ>}*s*Z!iKhK-h9LE$&Byr^oP};$Ky=vhb*L1pDI~
zWMyLvHPyl(@C6!3_Z$Adis{LylI<^_Uf$ObJFkw4$aKoQUX__G%M?WhhaHl1iAuG3
zpOamb37R>m+7;ovRvN(j8d)^i@){>rO3b`!I0k)yp~ms;;gV{_szz0L3Gnm8CWLY$
zg_dT-H=u&o@vr-`?1b$Kdy}J}dy;s5KNj@eNbUMQ6BDYPd|p3RmZtQ8*=!9d=mQpa
zIh=*pSiF~S@5d5ni9$YPVi^s6CXZgC=^x3M02&a*_ldq>;%U&>`czn|^J@p8CV1oD
zq!ed5T0q>Rw~A$3*Au5#neU4K;{B>vLGA{!lULb<pHV(Imx=>6US(%7%mT%1=W~8;
z6-&4L)I7VHZ|Mtsdlf6J5_G%Sc%mbFDM*qC3!W5&H-_`*=~myv#8WBB9L(iERk4hk
z2T6iQq^QPL*v)Qg)JIqn`9)FW&or0+3lmT6#@79`8=4k_iytLxpU-@Yp5+Vrv%;{D
zVLqE8Ww<6>AT~41XCYd%qA!U^85T$x$kmCy_#P}9fljK~OHMs2RkdHW+hSx(qiJG^
zQl|UDTFKt$PDi_>WCHNs&w)s1J9xYB)r9uvC0>ovd{Hyaw9aAaN5EH9uY;QWT$V;}
zL5;0<g)u?k69%wSZyaSLFyC){!vIz!tCzrL$m(G;h1gt?z*b%jJTcJ}Dh@a*9-n8E
zf|4RuAZmLDkiEtMRome3d!%^7RBemu+VJJ34AzU5+sHjb*|e;eu%G7-WC8DEWV|ls
zyN{0^=*Z-9n%$Af#paHL9d*fMcF82VEWYQYM#11ecKs&-qF8b_0cbI@_%$-9w{_p>
z+a<wD6A!7M3}opuMZ3SPPmCzWD^V9o+rtc8DCQmcMg)~AKL8ea>j>)uJ(Cu?!~sOb
zOUXp<(S7kd_?$tGLEWR*Mi@6sgoX63wySpcMi}P>$Y<=<y`5-njDdNJD7{Y?9g}UX
z&dVg{gIFS2`|)|bNQS3%VcL*Ew9sW>?lpF;)cL7FEZ3?djbE+%uGr3t2D5_EqPAD-
z!pc#X0<qcSYJKrnAj7yU>w1kN(qgn9#U>Q@re4*q`zGAXuN=$@8w8v7ZgmqMVrtjt
zpNm)PU3Kel7>y4Oz2)?l$`f0aHtHrV=qgj8W%c5D=<@n_-52*eo-)Ky<9L0nR3m(Y
zIHq^JK8sex$Y)BKYh_Vl3i2qIWet%(n$-slCd!+o`=~tO+)I8_XpZ$(M9}6+G&mY<
zX35t#p3ZGf1P%MLr1ayp;E<dCQ~eqp40MI!&#5`9bl=b19_m<sl|D6MAL8twDt)nZ
zIF8}<cXT*SwC}hIYTs)de>3iSS?r^#ssUt6e=|rIV?WtuFz$xavB=Z#M~AX}Zv~lD
zy6)S_KN`vkhlqAf*C&%qWFA6k>H0!dO{wY(N20}A@w2cSo$0>Mc=a$=G)K@geP*Pw
zytLH9^hIRS;wf5mCd1({K5r$tDO1`sx#zr>vH@`G;&r5$gd}D11H)KmBF%iR$IKeL
z$sGUFxRsw6#;UwO(I{}zS8z427|sgj2`NrSI$ovNxOZ|sEuE5W_7yUGtHzS?!4p?Y
z?F>>n>?>;hW0z(2IZ9*5QQtAXXE-ZdDA*sJ?zCG40u%M44RSK#aQ`&Iz4R){*0D0l
z{a;<&`?XUWJRe6MeBPD3as*4n#sUKMrJy64l~=t%ogy*t30Mukh}VyR`E167Uj?pC
z8BDKb@v{9JS=0(x8(mk{fc*b3aMk$txK$&Vj<8DXYQntNC=Q&5`>wdvFkmG~Ln;4E
zhJU?NZ^nHja23)RWxdV-$n>~9k5HEG{tAdubno`uFOehBtgf_#R)9n_tE*Q6=`8Y9
zrV~hb#P%&S*b6TQH7~Yr;Tx~Gv*_WS{-UWUJZp&kTW)O*Kt9^P<(B)me6)W{-n)FX
zf6J}yCayl(z9sL~_ARqM<s@?4p8fbQVrZkf#n47YVrZjLl}He6{3sDbyJD0IqV+f8
z`%rqOU4#m&AllfjU0(VP{+Y<I#V#*f?DDd^?efxZGRl#SAli>dIorJS+wFaT1!$X>
zzB85XwE%^y>UX67jJnbr{}2&TJcNFyaUJes-yPt*t=D(?j{;)52O?KX5Su6TXKWqZ
z0<?KTf7YUVsy1;Gn<w<=45A4qywwlOkNV5@62hk46Z)a}gUCT}D|(FnikC?2z`ex#
zl_W}}1jJWKUyc4J64`+&@&T{LQ35eH#7=+Bp!msz4A_^gzi$6d2tw6)LvT}ddoy}B
zg)-t{gb?+&j20piyE*ia?SDq(IjZEL%^dnCQl3QG%%Oi0C*=_zf%`-Vm#vA-9QrZi
zHZVw<C;ATAv99a>B-pKe0wB%iB(+@~?u#bWk_ioN$~aCmD^Ufx45CNr{@FzHIK~>?
zP6iFL@4&swJ_UVv><b}Mtd>j^x?eZ)fSZ)tRiv%^w-EVi5NdWWIB(tlJF-zCVc}bU
zVS_#ZlT2~Z_^_Xdi%t=7(fFvJ{a0kAlKVki^bNSz(oRrC5Es1!%Jyi<gsCGg`Zi=H
z4S_^T><r!i8$kA_{i)ni)DcS^C>`YzmY$;<ZzDg28PI=F$5ufKKTQ*xzYt3;nqQWM
zSZXTEP7^OZ5K2wWoRTJN6I%tTmt||o6q2nYlsX1nQu6yiKiJf4(<Xs5ir3QXb?^P4
zLq#c5U#c662@`SBVeB_S)b%To;t_Q%ix&kV>iW+hw9_c+8gr#MN(E%`m?;q%#VFhe
zXfj1z>rd*&WdsyK*Z8)jo#A#WhM?<ioDp<Qys{N*L|qHkS~5}M8<@sFi4CHzAFNSP
z*E*uEsT+CHDC$~A)U_0CUA9OiNYN<jT1V8iFib6(qONsBU6(+N6cKf;BkKCOh){^S
zmO@d~wT?ZM`yiB^Mp4%~_D~XH3O?;UVT_8p*0FW+3ILNS>RLzCHQ}d-sB3*Avr{pf
zOBHWp5p{h8cv_lx6^p2AO2K3ZRY%nIm&EyejLs=KqOPZdPBuTHuBAW}b&ZeIrc)M0
zU8ja|lS~vkqOJ>(h`kCnBrVS4_BUYsPM1;F=`!j%T}EA}%c$%0P0*d8r^~48bQyJ>
zE~Bo~>2*<*o-U)V(`D3kI(#=aN~O!F>vR=$oi3xU(`D3k`Yzza>gh7-I(;fqaeDf1
z&`G?WE~Bo~Wz=<gK7fgOx{SI`mr>X0GU_@VeFDQwx{SI`Z$PS-o-U)V(`D3kx{A6^
zmr>X0-J`BOeT=10M}o7Pm1Z&l>Z#bxN}UHz82%KSS??!UKy7BF4q*op2~-tJiLTA8
zXM;fkofIGR477F3ngcXpNcIehB_(SC>KdNG!u(tTjW>^DX+?zY8D>01q>n<=gFGYb
zHAG5pFFhkg*;?Qj-#w0{hJ|pWg>WfSxN3or9f%?}HNpym0Y3>hHksH|zye4TgLr$!
z89v;{p0?kXzLsK({kFE)Z)=PFwzk-BYm5E1w%BiLFLO6xB(lYZTU%_nwQ0kx*B1M2
zZL#0h7W-{&vESAf`)zHp-_{oUZEdmN*4_uIc+DUwu-|qIeljBaZO?)<&>G(}zH7fN
z!Lp&RzmM<QZ<`8Og0tWDVImSs%4M<>1k`?8%CH02Z`-?;$#1-1zwHJ9MQFR_PN5?f
z6P`z>O|inBEKD8(v<Pl(^ih|G+A&mHn}iQ^1?Zcg)@IQ-o&bGn%euf%-%nPd?N(H3
zDKHX_0+elC?4d(xCAUi?x3FZlr8~PzyR*AYvJ*yQT^{=i7^yFJSuv>>6K@Le4qEqm
z_7HFK(AIr^l3EK;P`9-w_8(NZCO+I{`7)m%8gWFKwb%0%9XKV49`n%|{aS#6x~(Sy
zA5lR83hK7@IUFb`+loy+MI1zcw)H1Z1&moTcuFy#aAxbE5IZG6VGq{Rf*V9Qi`d1d
z(=l-gbYEeG-}Iav;qaD{TX1+M_EVBO@EfXUy(>h(jD%vKt%P3Z69*9wZN2Y#D#G9c
zB?7(6w2lZhrUX7lwX7rQWcb+uS~s#j6vBbqmN*QVRv?XzN=Oi2%CbK8oQSYHs^p=7
zXzN()n^KP-5Q~)L-+-1v_u19}-BSY75W}N2P?ti8A=etLODVM2i%?(bU#&DhS&}^v
zf`u`8f%Dewqu|8s6Zmh~&tdp**_WYI)1HrF+;$0skFtjV;;|nEj@P~v5X)W$<wV;Q
z?;c~jfa$ZVz}as<Kpx%Z5ZJc&fGW;TM=A04ueeXJZ-FQQy8xJpVLKL}B>O(dl5A5A
zVO=DuHQ1m!#a@fjl-NW4<-|}Nt!3W`0^JrTLEGzv)IXpEmmP#eru{nZ-F6-75oOol
z-eVudy^2M)YK;%TI^ipD3#V8UZ3^d>y<$>46`_easWn-33W^}HrpRehCdDFKQ)Lcf
zkuxb4*_x)(nRX_{B3si{I>XMSSY&I4N~hbI6pL)lROw!}OEbRm^RbgzxjZl3!nd=6
z&`26ZoLcyH7A3Saia53K?JOF9J!uqiYSFi|?wrg@7gD6EHA)8`)afXiVo<bYKLW%+
z9lUjPbb#))z!nG+9izJTyFiQfiG&>}fJo7Csr!JI5}<{N==g+#_{oO*;^kA|q=;*D
zqA?G^1aaC>jAfrfB0#$_W1@vQYXSNYRZL7T%AjYA*YGP28;bE6be|wTL=_WjH=#V?
z8Drv=XQac&W8yPtu3!rZViJ@D^dYJke29wNK`?NbN=Ow>s3Pz=KQaZw4{?pjFnnN|
zMVnZCW&+LjvuG2m&z(p-vuG2m&yx~Ga0+noc?H~P$cC|cV`#>gAYw=TwoO4V0ebE2
zPY{Em7NB?D{(%2MWViw|;fno<e!?;}>p`2JGnM&7B&k2icoNXqu1HdUs=o^I+Y?a?
zwi=d`#fnH$TSSuDB9hb=k)*bWB(+5(sVyQ&Z4pUo(^{F&7Lla3h$OW|B&jVTNo^5H
zYRgDcTSSuDB9hb=k)*bWB(+5(sVyQ&Z4pUoUkZUrY!OLni%3#iM3UMflGGNFq_&78
zwM8VUEh0&65lL!`NK#uwlG-AY)RvK?wumIPMI@<xEu<b|i%3#ig9{#Ji%3%Y(=tSo
z+9HzF7Lla3h$OW|B&jVTNo^5HYKurxTSSuDB9hb=k)*bWB(+5(slB5Bk)*baB(+5(
zsVyQ&Z4pUoi%3#iM3UMflGNUlgGf?aM3UMflGHv4$Q)ZllG-AY)E1GXb|c{PZ4pUo
zi%3#iM3UMflGGNFq_&78wLgL`!*#ZZB(+5(sVyQ&Z4pUoYq^LdwPR85WwwYUwbMb+
zWQ#~rTSSuDB9hb=k)*bWB(+5(sVyQ&Z4pUow}7h67Lla3h$OW|B&jVUNo^5HYKurx
zTSSuDB9hb=k)-wr)MmXcB1vr#NotEoQd>ll+9HzF7Lla3h$OW|B&j_gMP6i!NK#uw
zlG-AY6b=LHhPH?#wM8VUEh9;75lLzv1ld)#h$OW|B&jVTNo^5HYKurxTSSuDB9hb=
zk)*bWB(+5(sVyQ&Z4pUoi%3%Y3-H`#i%3#iM3UMflGGNFq_&JCwVR;i+iVd@YKurx
zdlbm-utg-PEh0&65lL!`NK#uwlG-AY)E1GXwumIP4QOkREh0&65lL!`NK#uwlG-AY
z)E1GXwumIPWhALBB1vr#NotEoQd>ll+9HzF7Lla3h$OW|B&ppMNxE+)s~3@^{!fi1
za2N?9lGOh%n@*P(GcW(=spLuIyAJ;s;w?U2br7EaOM@cm5=11a|G3>N320TQg8ysr
zD2o{tI-vg>k<bGaN$Ni#5-dQGr2dm4;Y5=9zct<_c0WONw*PzkEMi9s#Qq<YJESR<
z|HlB8;|kF0QU6aFghf7|1QwB`{!>N~U<o3U)c=dUQ?S7h<o{JTQZ29@1z@)s`CdJ(
zcWgaUSPqhml8MZZNYWONC3QuT`VmR`4}feDNotEoQd>ll+A@+fnQ;AxBz+KADI${8
zk4VzQWQ?H*2o29>y)p>uN6hGFgd$=_{fHTDQYd?8tC&$gVn%7sW^2iW<WJCzT;QaL
zm{C7sM(I#S@tEsJ%qR^rS{e<We#DH@=xL{gsfLIdJrk3ml(gHaNf0wisfsj;8TBJ(
zlwLZFPqPRUF{8wCTAGL%^&@8V5+vuQQOu|xF{9TZwKy$-P!TgqY?h}{%%~qRqc<UM
zV;aSb`VljFD^gp;48o6?(L0d3ChY)mLCh#UtKOJKF{6IOj8f|6G>RGZBW9FR+tNhL
zs2?$-l)NR4Vn+Rl8Ku<rG{lVlIEM`sF{6IOjIM!7@?-JFiunWdc#7quNAZIzwxY_J
zxv^gU6A;2~?gO~JO1wcjIf&jM8HB{LjF*s|VBtQ<a_qWPm>fMhv0ODjxR_pZ<s}Fv
znO7naW(8^rl@-W5R*Bp~mCg(V=wKlhOd~cafiDLjQ7k5J*)UL&5vOwkR$}~yLSvUy
zM5OHPzXv3CCQ8=qePXo!FG$Sn`FKfZ*r}+c%XUM0Q^T7!(6N3-J18=)1J(;V>u;}4
zgXB5DW&={`UJKL%oelES`%q7y1U%WGR7wmAOd`Ps<x^sL;3rB97PY-G@L$AWa2A==
zu7F9p9b7_*#{x%0qW?jL$A%XIE2tVnvmeJy_^rS;XoU?El|C${P;5jzeg5;9h`M1T
z<0io-J$k|Ugf}X1FY2DHLm|sh0fQ>QMjMafzOXM<ELAtpgZRfs$+pZO>&B&TJB3;m
z9qhMA;P?s0*!tJ=ie4kZQuVZh0&w8G;PV8?(NhHbt%m`ia$(|YzyJ|2>w|x!1}@W+
zNax1Z_s-Lb|3tcq(|uQt;+M^1r7@56NBaF3dKI>dADo9sn_ozQ?*~hI5y`O)`7cn*
zf0aZJRTL>0JVrcSx{uy<QebA;Ux&#GY#`}z<=;g${V+`y`ZK`gS5keS@~x(~;kX8&
zJ?O%rhj?YwTa@@z1(ir21MU41)$6HQ)VNsjE4yN-q>7V2TK)-;vUg0fJqj(-N<Sll
z^{G_g{Js(^30;>ieOm(NrLu_i!<<U>7A)4!xE~nC*25d}DGr&1sZRX$`3SIioYGs9
zX}V68&aWe-T$e<=jIBRxsGv7SeUQM~d#fz4GFk>$X^*MOy@aae)7+iiU`jq4!&=!h
z10{OMsZ1V<V7pDpc}uwL5FvmHFSJO0@R&V-U$TJp4KF8|R;3ZIL6tHySK;W}c%+uA
zhDK^hFGJX>g=D;<mUS>O)|Rjy9+$ppn!gKAZET(WXHiQ;vX=jyti8#Xs@P*h5|_U1
zxePqT%7$s`CmUwDR{94*ukJ<m*IF(`xhG=9<1?XmipgTtL#bzxt@J)fEmb{M+Vu6|
z-omD<XB<Q^q}P1WuWOV=W6F(~dm+KIy2kgO1?zmW588B+$NfFU<>Oi>{!=@zLwQ9T
zOGS1DCCE119`fOR4?s}8+T-4!sLqK{y&s{f_GBum67fE^+EYbuV6o~NjE2eUH6D!3
zaN-C;4DKN*#(2EPAq0-Z(F$LOJJAPu;)ud1<7Y2qiELvj-?9*=y$R~UMBR;eNH^js
zL|o-DiQC(~WxYxw5?+i}K)v|q3t3jqG;~J2$m5PuXs<@lzEfzu7qQGa;uUg{XRNHi
zcv*p94-tyHMCf-f+=A|xBBYf{5x$7<zC2rsuze958Q+e+tlJK+x!}#eUW7o+#|H!M
z^|-$(k>qFzap~LkNpg{$E_J+I>pO*X$UN>#6#nuE{;3E)^EmiLWJy5pL#9OG3H`n&
zIo^&ES}QHq`PCtoH#reLUOyJ4zgjGXfC12P<NekV^53EoC~<R8=537>cvBAQ_oh#v
z^rHmaPElnR|1HD{D!wJvJQL-<x=4~m%O6<WR}r#jqH-kJ__A$$)?x%R|3bC9CCXh;
zDACmh2~a(o>lAiNR4!4`5;&E1C+N<2j7r-PCEn+frR_wA(Ql6us}mHbDUQp#J*tpa
zE66lQ!ZGQ0MJeMN72MK?d+J!`+_}VOca)e>7+e1o?!TQh^JJ9nRn^c6pCDVhD9R*O
z!waOC$09nJm*<FiQB<a?97(yMj%CFQDYrOME{Bx-ev}#(rCuXTWn1THg@1t0(pzLB
zHPH)wTz`+0@nxipmhNQ;l499iYGh|@i5h%A$S6)EC<;Hjd*L8xCl#TWqtjP4H?-i~
zU<YAwP)K!7H>pxE=;?!H&A;Xwm$0M+(fWg>6jTaT_3kBzwicxg>tgmbHSF*xIl13j
zD;sE}(?HYu7m!w`Md@ED-z=r6aTv^%(u{MYnIIcxMU*~FsVDdfNjF0^>0pG56!xbw
zOQjY^=SVF+5Yb{UI3;PlrBT_GfDX#)bNHruRxrDmd`pHT-Gs>qT?fQ}z_;B%q+$^<
zBPvJrEXgV(YLH|#zDO)|Wkgl01}Tfq;iu|ZmUR`G*mrLCkSw0Rloiy7MYiwUg$l1o
zXzn|Al}wK+8bqRe=N?IEiYzIcpC#o{HPXn8u3XB}y$_JP{?zThi9fUy!A*kkrw-#;
zlJTbw<7txdr;;(kYh;sr=Jsb6k}j5Og%imN-*rdrM#W#I1D|mHMf?YRTN>u+McerB
z284NvqTY26lrsJ?Od_prV3}DDk#{@n7VD=puoT`xwSUbm+|Rige0KvY$P}IRjcx@e
z5Y?X~(gA+FffX{?RZ1hvj2E~E9o)rbfeb#rk!9uk$y41dNgC7~V1X1FvR;a3HpqH;
zBg-aEyYVYI{l1G+Wjg<$k!4g*B-e1CTP%~}G)@eI&(k=z*6j``zSAQ*c#-(7!k~lf
zLP|hyMQ;q^BbTwna3-m*-R=G=P09hI5tqI#w%8$Scjr1}1*DmFcNHB)#NcH6UO)}M
z-0iMc^jAdaLlOGrUG!q9dbxWbjX!XKMPae9yxcun8q!%>->0dE%yGM4phy#3zZd@j
z+xAq1;T(6i6liXdpr7OJE$L?kg<=-DmCsxne1*Dfom=@>3{B<aE2p{L7YY7&4ycY4
z@KvOMX-)wkc!vb4b-PoQK+O?+dYvd0TN}ZbV_B^m&lpt0X+?D;K&^X}6cE#i8Ps$?
zn^FHn{Yvyi{_1izhxHlAOPW}({3{82kX!#eMb^G-YNEW^jp-g;!Rsq|QxhyCki;)<
z!kGf?NfMz^=4(?iHV4HVA=MrC7V>CgMdkYnt3hFPMzAs+thrj{_+-h;sp9V=Sb6Ta
zeS+6Ct@3e&C3x|&6)c(MrSP#USbzUo>fA5Ox+Nv>O94xuFfzafQvd?C=4~jdisi4Y
zKz|g&-K(Zp>om5$wITRpEO)I$)qY>e3-Rl}n8wFFlG}nfK5M1JZI8okzu>kF$dcQG
zr*nIGCCe!oN#*a7Ty*uEF<+@c-}bjMwBa)Yd15mg?*Ekvyj7xR+I(>{Ys&vK_1WK<
zQ8Ywd7Ay60eT4iaG$#7&7tO5P7F~>+aRkGb&$oE#DmFNO3ejIF>96oh`d=gT<KX>4
zzhxDx@xMxa>k^4M%g^6g#i|Mg&n*$2FGzZ=a4A{w28p}g$E#Xct^X!6)U{Ijd>_BO
zg`FW~S{I>zjQ^vBW%}oeky~PpL3nv9o9i1+?rgb)9pf#ntbdl+z}aMqr$L&Q72Zqw
z2}v9~nm^sjYJF>|)Oiy2Fi%;{`ezEd`Q7MVrShgpoOk)k)oem|C$&nIDO~I=6kUdE
zctkBrp^734CJ&S{dc+Z~zL1LQZN^iaz!x4#^I(MLzlcW6Bzv2~oQIO46UYb6RPo+|
z9&v?mWxVQamOkJpnQNM4_-d47sN5&~O<&YjGE6gvM;LYv<QJcfDY1yU$}vR<4$bnk
z!qMak<4lt}-8qWeyoh*Y%tfN`IJ4Jk7zIX}pkNYjdR0FS9*F~s1SgHrZ5?UcC)G4W
z@f=A!;kY2;I}xTnGhH%WE<KXZ4AO{5KDIxp+Gh?Rha-l!cWJ2bN~WjWvf6^F;8_l(
zNI|`hpo*v0EQ;{VAf{fke}w7%WRaQ~OHp0V^8;-xi9uCwwXr^7i*SE(3B{~b<t;#2
zbm`lkkCgY5E25YwRPR$RM=@IAl_c{?$-}33ERrn1BMp`zWj-0<QFI9vd(u^~QfhZv
zP%!<r8`EzH<4ei(AyX=%ORz-|reC^pofZ>3zUszf1W9^K@|b1vuiIJT2+_>PT$zff
zsD@nrF<0<3K|bwbGI*Jofw*GmDe*U6(}C?Bg66QRT+tMjNR%-Y!iH8Xn$nM74!rR7
zWOavJq9gTj$vPa0DCTLjid4)YSC$lKycFk<t5~ugB@O0~Yd8(cVty<v=8$V5H7*5t
z7sXJ|JLFnO?8w-w+8Ww5{S{aAKY5={78M>&jsL1sA$l|?(!%qp(O#6Yy=+L?7Dr^8
z46h(%d$EVAUW}+p%J!mbfHb`E(wJX#)kwP=RrDm4T=Jr8juh=NCE8yg8p<QL(Jz-!
zo^c7w+{r)al$QB@C(96_H^`by-a&MY*U4M&lDHo+De=LG#4glFO1#Te;xukM8Ne>r
za0*RiTW3j+v&$ts4n5VmNO$+R)QqHAD-2MJ?W8i$iTA5QFi#bizHNM@ke#jqS;%t9
zbf;^e6m+pxxRok(ixl)K#RFERcx;RCxW!fE2zmmUAQ>!qObgDdz*{VRyDMHw-mLYz
zkVL&eGCjr1*RrH3!jvy?l{ri}xy%b(H5Ac^+6H&f<I9Ck?Un{bAs4yC`(mN}i^%rp
zx=eae{{z2vEz2*SOlC3Hl`G${%nFJ@Zk{W)2`26}Jda7W2hXbHAFO3rvFFn0F-CG|
z&~)xw$8sf)F|HiRW3J>e))o7q;GuQnF?Suy@+DJGFO@u=;1{lA`Sae9pe$N5z&ioS
zp|>mcax{<EIKEd&aRc?cJ}wd6hzbSQlj19I<OuTVAzrxfzFi8y#2R~sviu*@Xr3ZV
zobnqlKL>L)QDllMM;19v7Mbc4dHA#<)4Pg%gY=c*Qjev}w8EPSaLmx@>HfoCWTUGM
zig1Qc426}7iMB!^cX2VQv6yHm8k)>h$c?n@CgY15g^zO5ql!jQLnEI$o^T2jHbnrM
z2a;0=Zoq3v{Zk{3$|KFpj^-8T;*p}7tmug0ry=tNC0&{n64IR{=>+K!qmLwAto7YQ
z%-=TLYZd<V2!8%B2mfs&R~4o8{e=4IA;bOC&l2(c2>ylP2*DwTU~Z8Nr8Wl1S^21<
zRx0n1F;3QgT2MqYzhXol6AC{jb=)dd{LCrIeV{Z6RAS0-N5u*S9bKpxBw?lE8mVF+
zP$5EvLdOvR{Hjng08+_#RV0)QfK>AKaBv4zbh{BtC6c+#jz;=6N6@)t)06_*l>&k_
zVd{|&7&)^9#d5^)cxa8p?V-T$ek;gyZj_C4x2jiH<6K4c5_6~<jZ#&l)^{#7=%t1`
zTj5_CQTF>0{7a2Yi9a_i-(y{7q)G`E2gL`_FL%;-q`He3t~cE0{v<iw8DThLgd@QE
z2t(O;>y5rn<B1se^~PwY@r12!aCBm0+Vmc|j1jW+4)R0mS<)PVq(I`W9Q6pop$=he
z-5Hk61%Pa>8^f|oL;%;Q<^n)A*A_GvA9g<Gf}&AIIRcETbpI$TbepQz2+Xd6l~mqT
z!$%K-qW^qACN|CRktZSZC<`dEdPP>Xn)dN}b+jAoOVi4BD}*N%Lh$!A_AEy5j%12=
z8iHw^!xS%K_VMq}XGOl<WJd#KyWho2H?Tr$Hkm>n!(H_~U$BAYvr*skO&eI2SEIgB
zY~aL=yMY#-K#stYx*YPIEcpQ?fWGbUD5obV6vx>R$!Wd@Y1v@P*F@6F*C2hmuK@tv
zV5C%*P;s=Q;^o?qc~o^nRwz%2l^hYP?{$>@GjsoqUm0fkS)%oSX1Vg!>Ugd2a<Y&g
zn0P_D?puB+%<@JGq#szRM4DSvM>YR}4ODg}?coQeoCcV@Kuk_bCgtDqz8hIyxnOdV
z<(<alB<rJ?XoZbr{KqBH`}~59EWcd%;^VBh#F;A#I?e_~XznK4`CQW6!e0kXmZ15Z
z<x8CLTE7_T_r=U4*AY0$Q#P?NtbQO5ZDOT;M^jVJjG+nN6DOpS=0|ijyBdo*hiSN)
znR!2;Xu;ku^ZlDxrf)Zy=u|N+z3c@4WD^_ddx5NDq5w6X;QcnUJl_H;d7J>1o#6EZ
z`h*0o79i^czYd`MH8kE1@jZePUj0TE4ynYYZ#%mNGCbaozq6U8$GC?8bATYeeJ{I!
z)tgy`T5SS+SS-Tv=q4&jGdx40hei(;Ne|z20Skn^hzRwk!$DezHSkAAO9UPG(LUrj
z_=A8E;{!vw@g?Zp5fOaQJsI1b4vX5lUYkJt;&LE&d{sB5BU6Xb_tp|}z?VLz8>rI8
zB{(Ir6hvy4>myTn#uY3zJ<04QJ>?}6r`m+7RF<+g>oT@T-+RfW?EOI0XJBM#&++Vs
z*x<c)+`>9^*YM?LFP^cTEh_GZ!-ifoQ!g|NHk-b3(;Q~Tv1N&7?mjc_gqh+=Fyk&*
zXy)%TOZm?2EW5POGttap1qo)a{btc-Gf-}(&odJ*FbmHziwRuhi8u2uFthfXnf#0G
ztSKt*EYo+w4Dy9L@Pa3}kT2T7lK2%nFl)})Z)Ouo<`Wl~sk=>kpBZzJsZTU3mz#yG
zB4Czunx$*Zf=;u%(+qZ+`D@I=PP2H8S%l;oGquyy=bHm7{%NLtY?>FaU;-^UyRX52
z=84CD*IYA+e%!2oz>KB4lV;);GXp#}n{nkP58j3yV0nDwZS4No(a6^~o3-@QVGiOW
zZfEI*m7e{kxz9}U1kCgkX3|MBhQv*{(Ddvx3wN8*`%UjWRCD9)tZzCh6LZ2W?KESa
zq&f_&Ff)mA(g`#DBtLXJJHyEHRPyAVY*0d(rxFzmCYV+G%-;72<?$suS-D=!x9-HE
zVD5f?&rTMq%{^-N_EeZbpl&zwi6CzuwM5B&v_LS?%#a`yv)@d4%k-@?V?HtQ4rPQW
zJBwt^Kx@Qa$Y<Tb-uLwNTx%xpGgJAHJJ~hvd^R{>Ch$XdvP69tKYAyE1Y)`8F7}tG
z>I$lK27mi5Hb76|_AW#R^x`9Su>w7VFWtqe!8OUu;rHxfy`%Dthr)Bwy6^5{b-9D*
znHf)-DUD`1gxG8r>@d@xG;^;t%Qu_7%FV=iW-(uMHyhv^v&xJo=}hQ1neVuprRk}B
z|K04SsK22<7}_PmQq7KYRyVZs#SgJjGsSKBa^xZEqg?Z{jya;oYeuqe#-1?EMl)f*
zX*Zg^=9>xM(@n}e(?^ZzdCFMpdE*Q-rU<HG3_He#fr+90S(L$VxQG3Y8E5jcd*MHm
z|2sn>;}K?5i2l&K!%UfAdN1U0_psb#GAxgqO;4aoCr>cb*ND>jWB0N(#ym5N_q&g6
z(}(gy_pxGgn43)r@K^3*L0-6<ogK9vPe1r_ixlO}-RxpEI>bYJSf!r8x9(w$y=PTW
zgJ*2Mz|{AdgGQiXs7~$|%v`tUEi<s$G&h@GfQ&xoJf3$yn;ks{t#`uIJ@d@b{DS-0
zxTzTxrq?sq%#=Tgm1Y7`zRm$Trq?*P+|+~S#1SXVyv?S^)5nZQmxIl3Hj{rb^?b9Y
zf{fa;+3YjV^lmowkIj+1*8}X#Y2!zjrO^83k5SSxbIeHc6?v>G!L0X`n|ZhXr=L!9
z3FUQ)yosG=?F2J#g1P#i0>qzwfK`pHnMAVt!4XBGYnh%msou3C%m4~|!l~&<s<5Zb
zG)WgvtTO|i<=u1num@R#FZ)fixWkN_V8+Zh%lGbi5Z%j-gKOFRmHfkp*znj9L_EQ)
zp`XoWe_sAD+p3S_2OegV^%30vM>ZCz*?(lYu2B_c{ND5a$ZlnJpEag;yP5Z`nYbC<
z%8chFd)eCXxC-GaSyjOF9fj~kkf&_3X-_aS7MO7xS>GhHXaRMC9uVM6o?y-r@IDL8
z0q{y=%|4UO{<s-uW=ta5U^3C#9b{dJ9pr0$pPE&(%^{o3^a-Z#BC~Ko3}we{HT$9H
z!MyilY?4`l+kyQ2$5@^|mhX6sT~H_*$4d>+2j=kK{qPBovkbkOFMpg3b&anu1N^SX
zS+PEH?<<e9b9Mdky_5E_e$4C-Js#&5KFL03!!O#~_9wPO*PD3Y09&Bf?OlC<t<V=_
zkui8Zjb<J!2S2^!Pp0}IAv(+)`IAXMji#?Jr1n;tF?puG+idhK2Q2?%Go!=wO)_y`
zMol%>Ead&4Mh6+kmp#pD^@V#Me3~uS^~Swv&$2yw>T>s6o?(j2oaDLHjPYzIc1!t@
z=hy*#>E7F(XDvD$S=<XO!MDismq;PWyz&J$E8%P~aLV<f+;h!ddvAP!?T^wM`0PV$
zgPzX+eu%Z{nS9(UEEDx@e1*-^^*VmwRW`|6<9^GGhI^0YiLbHUdJTW(HCCIL(rJ31
zFooIn5njo-2E8-q@9duJa$|qklZ{QP&*4ioGd=s!G;v2w`)f02gc<BGhwy*>oh^x-
z07q$~d#0e5mYcQwtk>CeeKOzkI@|BbhD#z#-`n;EdnZc2eedM=+4l*0(%v!OundD=
z^DRc&)|Cw{p;>UJp@|LWtZi*u8XDW$*3h)9MVr-?HMYIEu6=oE%-NlF&E4UX8X7x7
zqubhA*LH`_JZIIC)@H4Jd23roc2i47_q<6>9Sv=D&7oOsoef%R%Q@k7p=Avnp$;mm
zJDwv<b!$sUQwwmLTU(Z8i+`Oh?GUeFX;0P;$(ZK$2CcCP%lLJx8njTT6C(8M8|u)S
zn_3z|EuE{DG_*yEnuLm1w|1T`<doJ9Ro5lULv_u~t@U*stz9(TbTzH5wO*Ura?U!T
zEWYV`yqsukYiNk@?}j^O-D)UA>sZ;+bZ$2ZfH4_0Z2x!dj&84SY6^|P#^-KL;nZ?Q
zLq}&@OE<NUqMO=7Yx|%LyAzCSYp8?H|DFBpmX$57Yg_oR1x8w7w-TybSFLIQvrq^u
z2UJ0EqIF1UzUF%t40PGWv}Q+c{>SfG1uy&oXO(ti<p@hn($uIeYi?bFwr{U*tLv!m
zuG#v!)phkv9p`kH+o3%J@~`|)8D}m>8~=NTy)-nlqph>PLqp?*>e|})H$SjpK~WoF
z2KAk7r?sVHlAvm8S;o)*5wE<v)nQUY`+sN~N4na^?h-hx#@3MyE^X~xa=L^wnwBj;
zt;0~q6ZSI}b(x04-G!<{e8o@9=9|A~0e;6%EIqNCI8MQ{+xb&JvE&(DjUjsHzc(}N
zhZNFKw@NXm2~&vrMtgVBXLi&n8{s>C#58<Uy^(xow{o4TP3c_K(AHGnozxMjx~~1S
zzCNv?tsaJ?M3OF~p86UO&(L#vpV8D(*LF^5>go`wSR38m5t`TpVMn)9{}v`lO%-bI
zSk=L=JH>MO6Q@{NmJq+GrLi^C(z>*viws?HSzFyIp7ArQ&YSJ9mNLzoHYQX%W$e_@
z#M&t}q1m-lW(}y~n|@&leA~|~Fk(qlOQ?0V<k!-$4BbWEcS+dg5$apfA0g``IEChM
zZLOWFdGar;Z-(O043F3))9AKkP!}q^<`-6RCe?6kbKNpHoEB&bofZ9Z6|?{kw@kS}
z;K=$%%Ft$=E<J?r*OzjobW>OJfBnL8!%}w<iM6`+&=NSVm0Cm<Q$)?Q2#Rz&8v06u
zLTzhprEWiM#+X^N=7q-2o>D!lcIuQ+s2hzO0?6Y{Mx)g&YtUBLwY4{d_?}-`RjJd2
z!mO#fqCthKgi=K9Yg@<>^X%W)fOP4dD+j>IM9>|9`8mI_N{_54YI*l>Y+wyWjCCPV
zVp~Y~S!BZ^VVqt3;lEaQG{N;pIF7*x)kaAwzg;x^4b4V;xC4#e+_0vhSu}S$28a&X
z@QqDv5FX{A)AUgPoT;@nU7WjyCmIRc<-pfXJHo8tBS^C$ctGlQs->q+;lp&JI8mC!
zq%{~>SGP5+2`v*gC5&^DZg}{RUzs%vC$A9#RiU$`zN4uXgXQUFamLiClPF($Mck0;
zwKj4%8V2u<5RGDjgKU)AM!t|4z3eV?sA*c$w6sBXi_4giVS|ZkKsjj3tjC#=7)F+8
zrm3sD*~a9~=8mS-&F6HfN3?uM^pfs)txG#Ga7fE(3yE3_zeinSNh_uf(x#}VcO&cO
zh!Z6O#&YsSA+#G!D)<<~n3L`Z9Z`g=!!&A4e!pRi=e=A;CErZFe~rtCEq3fJgibC*
z7gj1q>xQM>oTg(q(b=T?F4Wo<8adkG6rq+gsMASJwHk(-pK=)mxqz$jdMyoF(#Rs}
zt;Q6C51DE7>I0DDGL#NvAMQdGQxznshb`p~m`1M8sjwI*`4^^<5gWlDCq`T;PP*HO
zo4cxYsj|PWu0&#!45CJ&$BIg5^>twFI9X>_7-1c$bx6oB3^wdGaso^0F!n{zWWD*V
zZX+cZ=7rf@V^c$0yM}?ey<6j|S&Ec&UzFjs#>|BunmH2=h#z+weH*$Ab@bAuWGQ0y
z(p8X}b)w)YG%iRBX;=sA!gzxIf{fYS1v@R_^eVnJ%2*ig(Y3}-nmU?%ZWpuA($*GH
zN2y<}qYeXos2x)zRc?C+1`#oYb%}lYL@c5pN3j^9!J?xM*0aT9tP7t}2aA%nI~K<e
zwYSyxp(dkF(OzD!b<3_Dq*B6g)c_ru+P1Wz4ffj|5qxA)U^*CNO9I>-H#`<K?naAO
z`Q1|yPQqSlD+g#oFwD0aLiKRK7}IF()6m?oN?RgoBJwpVOIGUNN}L@jkfaNTU|<c)
zFj4MS?2Nj#t2-QssKadaFwl*0Z3|pwlT&elHLVp>S(<Z4N|$r~Zmj3DIwVA)oe>s7
z3+glAk{asZaU;|Yzi#w|Bt;dDSLO)v$czc(rxS{7F&U`CG>O=ERd({yQ0-|7!8p-c
zhxrw-x|JZ*KO5>_Ti3i2H59$Ny#Wn?DHZiy`TWA&IMsg;4R<sOw2LX{%!XCdfQ5-)
z2O4VK>W2D`hNU5lG<dEEb&xRa%j=f5u7#hu#%oOND<)%tUXD=_lT^jQC_CEf)}V7^
zj(>J%LuUg&<uy`SQzMVDjIlg-iIK<`Sw<?)oP|vek6T8c=%!WlOcYv)v5J3U8B_W4
zSw<Y69&Ie<-}sCK{?}-um|qiZxcGRV5#ZlN8&~jGXY29&-Wa2WR}w7AXO!~=KBJWX
zBi2af2mC<Z;WI`>p(dmNe%NQ6>!UF_;<5PjSP-uFLmt6<kKf4RoBfdNZ+>GNpHIoF
zVvSk+$5^9=U+e?h;kMyPL!XWC5DpVoB|Sgi6k`PTuC|T!dhBXxZ0#B<MRUJXamKv(
z*3ORAogL^JOB>puXgDOkDBh@yYVWMChlAn|#2W=39CaUB(%IO^uUM#Od*F3yLW4px
z_ogNog?ikwh87HRn3_`4gz%LOJ|bYeXyTD(>I`0!XcR}S>J)y6Hzyhy{DwqhBrjj0
z7jbNQuZRYk;y0U*NiwSVg-OPsm@{ib=;ooBv!>1%!}lc_)5f1UdgkQN<k915s{x%+
zJ7t{K2m~=}*9aTWgX3m7cQv(hwAR%mRco8H7#x%)k@?niXsssMxWED#EICv?Yd$}e
zY}~+Crx@8b0f8%I!t`%8|3iu~y!Vo(7T74pQgm{KF=o2B1A{Ts=Q{<@oIYa~{~^UF
z@G7ivV|ZGs@hwkFGv@NXiLjir(~JV%cd?$tkHj0PvE-9z<ZYBMH~6z@#&-o6BkERl
zRgMG_s&L9i{UF)NUdDi$Gwa${)e2+P99FWYXe|xvIzo+@l~J2$jcu)~=$9H=w57vq
z=Ik^0nd!#RK0?D{gc0Kk94YERt$>=M-WVeZFllP_=t-e*V`lNKbB!eaA!*Z{Vf5$Y
zGK@F*)$v9i&&o6&<t<r8FaBO8k}+AZ+5uU{Aig=vXyo5!8G|$N1l+W$ZnY=@m76gJ
z4-aEz(EOgX&*x<uwNX^-(Nk*pE!oEUB5M6PV`k8(>ky4TW2Uy6szU&3$hok$;vAzi
zTecSQm)*FXFeZ<gJaxvr(9GKTV|Yi7G0>}8f6{z@caE_`SOZF&GDhRaS6~fcNv_eF
z-_o!auK?(Qy}e~MdQ?YaXic5g*^Wn4xN`Y0$iK{mA`<e9;NI#yV+G^;3XBK&`a<Il
z&hm}K=<#E!Cx*t%m@#$6OrBk2jOhz*OS+h0+^E#(RS>2>p-%L)%D#id8v;3Y*TciN
z@ym*gr+HJ*c*Vp(43{*x*jS$3+8)BJsX<$EPDcaYue7zoUDB%sNw~U`_pXEH-zzq_
zpNd5P#oLyqmZpxqZ6(Hex@$RJo$dX+)c8i{|12|(@mI=?%e-}%T8TGHd*}BtzSG%_
zaePLlv50M{<_}dG<@(?GkxDFJJivdfH11*t9^HFeUt@rd8~#o|<4$()QNFnf=L#Nr
zbnin|#uOG_fDi*6N7HFDu>gxJQLce#9B`NR^=~Q}`MCpdrunq$xe`QYjM4STe}n(D
z!XF)ycq&p|driW_+Wf^bW3T+tjwph-Ith4J!RZs(RPg5tUaH`XLJ$B?ULpaPD7aIx
zL#kr&3La4Sw+MWMx!JPfT5pxHr(R+r;$B>X75q&FS3lYq1@|J3g|1EVM>|Wwhb)zV
zuN0gPEhIrNQ}|B#+IcFYSVXO3FR3E9Qo%1!aIENyiw>S6Mo%dCQ3bz4!MCe;`_T&i
zkb)mkaJ3Ijdj{}Cp;9H$b&B9Meq@l596qAx=C73Sc(edr-za#=I+?x~X}S!oJQ2I*
zRWf}-{%AM|N5DfZ67Zserz&{w^CjSU1uvFx9DCg=Avdaw{)(V{g9O~8;B+<|6?{P9
zukgqW#{^cNDVsP>;ZIWdub(FYDqEYU;NJ*=@^G|?B4||^Z>fTvy?7gV-4G+W@=|2$
zTCz6k5n0YPij0n8B)J~jECFi2gm#}KdrXlXR%9<IGDmD}fn<lyDXu>Yvhb^l>+p*t
zI9=8DJq4e4rG#HCf3y<{eoVoKORk#Nl+x|IRwB+-@LmdDpcp)-;KdRi);?496KD8=
zb~G}`g*eCYB5FWfXDUWl{Fh9pC`OGAe7l5SEPu3f6g=*C5-=Eo({-VOPq>*<=&@(G
z=?34fQyGh%m1(ykxI@8zRt60t7uVx}lc3J2$pH!0URLn!%cO)(2+`Y$Py7yv*oXL_
zeC-oOfaA4Aj$h_$zbJz4r;AgT4+4`RELBY$R6Qn5!SCB887Nn!6)E^{cT0FEP5zDm
zJWMrkPF_!zaBUVc2=1Iek2nx<tx)joO;S+DGU<b9B+$;kN<2EcmoED9x{hPI7Vnk#
z8wC{K1XTE^UJ~_3n2f5yovHxmdk3lov_C3>o?nW1S;39hC1>Zu7ZICRv7)vr_yfh?
z`2d(pm9KrRGMrC<IR*c!3V8T^$w6sQi@|<us&UUxx1=a|&#%P<75u})l21S?L>o${
zTN0!1j>wD~RmKzrzv?3ir!#-)s#ox-U&!<pg}+9@ANg3q=?h16U9R9=A9RxN?Fv5c
zjZY<@PBHqU%INu7t)~_I%`YXs+V!Ztq~JY2Xm*6hjfB@fhHNqcC*;>@iLVvhi9UAV
zKPk8q*X%Te0k=eaoS13lrL-8_kp6yiN%?0>>9kylAJ(!TQx#JslqyEq&JH65uX5mT
zosK_Tz>_uSuo5K2H4ZmaaL*$H=!5kHm!}V)duJ(vW|h(N)PoHQ-t)`{$A+Dw865X=
zt-|kl48@%azH6AQz{k|5h=@*kAc?LVB{S-IQ$Hii`)7c4El$G}Z<JA#`Z|(yuI2IF
zs{WM3b(H6fMmv6`vXAx1W?n+FwZE$aBq&8!BH+4~gpX^U&d!73hiTE8mMzdC|4M-$
z4<R>JOMJLKaSfI560K)I<_tw}{6dKsQ8PaRc`G-l>|0f~6J~v_f}gg<2pqNxveZXZ
z_GjNot`p>s_7{<@f56W^!$_`O1P`5!5&A%n%AHcwr*v5fX9i?rUl&#G@r{z*Z!%lU
z;je&Qm_Bk(**!PPj#Ka<s;`YxWM?Y)O_>s~LkYP|!KeHt0nX;ewF=&I!|W9j9@f_T
zB%`+!BaVzX_<!ePj;dUIUR4SjI4Kb?Q}|CQc+c%^uPb=ZvkE>_aCx%)P#i*{82z9!
zdL9hng29l6E>x}AOW~*UoEjrJwL)d%00oh8mJ;}VJ{{TNYL(sdbB;?Cyys^0vjN9h
zPTB+Nd?Hntwoc*q48`A~;5~zLZw4G{oUb{bw{-M)pCagamH-`iO4aNce%_z#iutuI
zs&hC3y&$ST`8`F}^OS}!6ujqVPC6Bpn%DU<rz2K$42rpKG)urXC@IJ-s-Z`z66pw4
z5^$E<-Z@CYM<{sDz0p$@yk{8fV!-3z%{4VK2r53U0*>>}vmcg1dDJj=o?`U33nZrV
zcy|@SNo4VD0}`$0mbpC+#^e_T^H?ocO@y6lzpHrn+*42I0u#rcM}d6naIEwCBu39|
zNhu2cyxP9kUsbPA!EH6;clsNhgi0lqs44wdYC2TSr;meqpNVX0FXwxxj^K@a6SDQS
z0;}#a#iZvpnVkxLnR<Y#P{KSUxTa{+R2w)W@CyoGZX55~HU1`#8;{by5T#Ydzy*@X
zV`8K<A1JQL3SRZS1hgx7Z+<qY!*muek@Y;OV}gRO`&QyR!}wW%Q&;TiX`2*&&y5}H
z0Vl&6r79&xEwJ1o@HHM)YsBH0A-xtu#Dj{*T}o6nE7s^xWRkJxx9yJbI*`>KSJ|`F
zHp)e+hG-x`)^n?eU%@{LOT;%6ekMN%c4jGMi%vH}A#Tc+Dm|bOCj(B+uT7J1XG(OI
z!tWX9zFfh3ZsT98;0x5&a0;KN>p}?+V@t1uIByJYPy{_UjNYx_J$DPyS$3qjA29OM
zrS?H;bfhaaN<|M#`&{9_FT4!YGfj|b+Ak`@R{pL*!Rh2yDxl}?&rAjHxm9|og2!GY
z8I&tN6BPWkUFu7bIa_5IWwHk9iC(Kya7*=}JjH00f<K`~+<O&#Cn{j0#@WY|jum_f
ze`O*%^m&S`=N_=jxjqTme^A+Jsu#>xOm>Oktdfq7CFVVcrxz8Oai%P7lp_0wAglXY
zW%oR(?K=hUxnJ49`wdd|kbKFGPVlBHUctjnGX1V9rigzH;cJJf>;vf%{)EKRCMtN(
zgOcVdc+c(G4T4>Gt;+8CwZy9x{9#KLvrrYYO~Kz)JMA48d#8dQQ?A#+->cv|m9ds8
zKF>(_{C_*j>Saany)uz?ir^m#-g9^TDFyF&%7?`(r@|p-;6);7x#u?e5(V#hjMZ=j
z|C@4@b5!wT0FPt;K4+Oua5zxyA*m;iYORpuQ=;|U`+K%3fKD}{Ym)rYws36eN>05^
zWjCsxpo~L%L{{fzmEH4*viBAITy<`Z<KO?K;D4AYi=od6(Dkc=_dKr3pCHwhsa~^w
zB+<1r2@h-7HY-5asf<!Z&~sDvPz6s)koW;L(HO7bWhW#9?CufQJOw|f28+iP{yGKE
z7gK0-k-3WCVm^Hu+V?h<U#{9~g37*6!JS<KS1b5I1%Fu$D{Tt?l7ja<z2*Z2f8iI2
z=nP^fCA?be`NdTq9tp|dzE<ZIty2~0rQkicX$J#)<EI;UuqayZ!;1gjhh`dYd!v_h
zEvE0iY@yLNDnaC*zVN>HiKT|0?R~D%$Yc1fBmZo<QEuIc4nY@|8giSA=b4$yKWhTq
zncQOOA$Nr_7E2FJD~vvI&V!}%`yRiWzz?jE?dJRj_kOwp8&cVEldot7w*zYK{=l95
zwq|35`M{mPziu>E<g%M|7yr50$oD=?FkFXu@hW4Wb=xkPtUAnBtTF~zZ)}mOS(D7~
zLE1ZMyG*~sKLxtC@E4gp!i!swj8exz9_MjQ*c-9F#mG<mLBT3=L^&G$Ji#AnF?xIE
Z%PHP4{wav9rSvu*7rxZ{S)-BpzW|V~1h4=A

delta 75202
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
WO{RdrRiJ-Zv%G|(LKBzM)c*%6P_5zs

diff --git a/progs/test.onyx b/progs/test.onyx
index 5da6fd85..db16c2b9 100644
--- a/progs/test.onyx
+++ b/progs/test.onyx
@@ -62,6 +62,7 @@ export main2 :: proc {
 // }
 
 export main :: proc {
+    print_i32(clz_i32(16));
     print_f32(sqrt_f32(2.0f));
 
     print_i32(5 * 6 + 2 * 3);
diff --git a/src/onyx.c b/src/onyx.c
index 680cff77..7c2abd82 100644
--- a/src/onyx.c
+++ b/src/onyx.c
@@ -144,24 +144,24 @@ static CompilerProgress process_source_file(CompilerState* compiler_state, char*
 
     bh_arr(AstNode *) top_nodes = parse_source_file(compiler_state, &fc);
 
-    bh_arr(AstNodeUse *) uses = NULL;
+    bh_arr(AstUse *) uses = NULL;
 
     bh_arr_each(AstNode *, node, top_nodes) {
         switch ((*node)->kind) {
-            case AST_NODE_KIND_USE:
-                bh_arr_push(uses, (AstNodeUse *) *node);
+            case Ast_Kind_Use:
+                bh_arr_push(uses, (AstUse *) *node);
                 break;
 
-            case AST_NODE_KIND_GLOBAL:
-                bh_arr_push(compiler_state->program.globals, (AstNodeGlobal *) (*node));
+            case Ast_Kind_Global:
+                bh_arr_push(compiler_state->program.globals, (AstGlobal *) (*node));
                 break;
 
-            case AST_NODE_KIND_FOREIGN:
-                bh_arr_push(compiler_state->program.foreigns, (AstNodeForeign *) (*node));
+            case Ast_Kind_Foreign:
+                bh_arr_push(compiler_state->program.foreigns, (AstForeign *) (*node));
                 break;
 
-            case AST_NODE_KIND_FUNCTION:
-                bh_arr_push(compiler_state->program.functions, (AstNodeFunction *) (*node));
+            case Ast_Kind_Function:
+                bh_arr_push(compiler_state->program.functions, (AstFunction *) (*node));
                 break;
 
             default:
@@ -170,7 +170,7 @@ static CompilerProgress process_source_file(CompilerState* compiler_state, char*
         }
     }
 
-    bh_arr_each(AstNodeUse *, use_node, uses) {
+    bh_arr_each(AstUse *, use_node, uses) {
         char* formatted_name = bh_aprintf(
                 global_heap_allocator,
                 "%b.onyx",
diff --git a/src/onyxchecker.c b/src/onyxchecker.c
index 1361d78a..c7d0fcd7 100644
--- a/src/onyxchecker.c
+++ b/src/onyxchecker.c
@@ -1,20 +1,20 @@
 #define BH_DEBUG
 #include "onyxsempass.h"
 
-static void check_function(OnyxSemPassState* state, AstNodeFunction* func);
-static void check_block(OnyxSemPassState* state, AstNodeBlock* block);
+static void check_function(OnyxSemPassState* state, AstFunction* func);
+static void check_block(OnyxSemPassState* state, AstBlock* block);
 static void check_statement_chain(OnyxSemPassState* state, AstNode* start);
 static void check_statement(OnyxSemPassState* state, AstNode* stmt);
-static void check_assignment(OnyxSemPassState* state, AstNodeAssign* assign);
-static void check_return(OnyxSemPassState* state, AstNodeReturn* retnode);
-static void check_if(OnyxSemPassState* state, AstNodeIf* ifnode);
-static void check_while(OnyxSemPassState* state, AstNodeWhile* whilenode);
-static void check_call(OnyxSemPassState* state, AstNodeCall* call);
-static void check_expression(OnyxSemPassState* state, AstNodeTyped* expr);
-static void check_global(OnyxSemPassState* state, AstNodeGlobal* global);
-
-static void check_assignment(OnyxSemPassState* state, AstNodeAssign* assign) {
-    if (assign->lval->kind == AST_NODE_KIND_SYMBOL) {
+static void check_assignment(OnyxSemPassState* state, AstAssign* assign);
+static void check_return(OnyxSemPassState* state, AstReturn* retnode);
+static void check_if(OnyxSemPassState* state, AstIf* ifnode);
+static void check_while(OnyxSemPassState* state, AstWhile* whilenode);
+static void check_call(OnyxSemPassState* state, AstCall* call);
+static void check_expression(OnyxSemPassState* state, AstTyped* expr);
+static void check_global(OnyxSemPassState* state, AstGlobal* global);
+
+static void check_assignment(OnyxSemPassState* state, AstAssign* assign) {
+    if (assign->lval->kind == Ast_Kind_Symbol) {
         onyx_message_add(state->msgs,
                 ONYX_MESSAGE_TYPE_UNRESOLVED_SYMBOL,
                 assign->lval->token->pos,
@@ -22,7 +22,7 @@ static void check_assignment(OnyxSemPassState* state, AstNodeAssign* assign) {
         return;
     }
 
-    if ((assign->lval->flags & ONYX_AST_FLAG_CONST) != 0 && assign->lval->type->is_known) {
+    if ((assign->lval->flags & Ast_Flag_Const) != 0 && assign->lval->type->is_known) {
         onyx_message_add(state->msgs,
                 ONYX_MESSAGE_TYPE_ASSIGN_CONST,
                 assign->base.token->pos,
@@ -30,7 +30,7 @@ static void check_assignment(OnyxSemPassState* state, AstNodeAssign* assign) {
         return;
     }
 
-    if ((assign->lval->flags & ONYX_AST_FLAG_LVAL) == 0) {
+    if ((assign->lval->flags & Ast_Flag_Lval) == 0) {
         onyx_message_add(state->msgs,
                 ONYX_MESSAGE_TYPE_NOT_LVAL,
                 assign->base.token->pos,
@@ -53,7 +53,7 @@ static void check_assignment(OnyxSemPassState* state, AstNodeAssign* assign) {
     }
 }
 
-static void check_return(OnyxSemPassState* state, AstNodeReturn* retnode) {
+static void check_return(OnyxSemPassState* state, AstReturn* retnode) {
     if (retnode->expr) {
         check_expression(state, retnode->expr);
 
@@ -73,7 +73,7 @@ static void check_return(OnyxSemPassState* state, AstNodeReturn* retnode) {
     }
 }
 
-static void check_if(OnyxSemPassState* state, AstNodeIf* ifnode) {
+static void check_if(OnyxSemPassState* state, AstIf* ifnode) {
     check_expression(state, ifnode->cond);
     if (ifnode->cond->type != &builtin_types[TYPE_INFO_KIND_BOOL]) {
         onyx_message_add(state->msgs,
@@ -87,7 +87,7 @@ static void check_if(OnyxSemPassState* state, AstNodeIf* ifnode) {
     if (ifnode->false_block.as_if) check_statement(state, (AstNode *) ifnode->false_block.as_block);
 }
 
-static void check_while(OnyxSemPassState* state, AstNodeWhile* whilenode) {
+static void check_while(OnyxSemPassState* state, AstWhile* whilenode) {
     check_expression(state, whilenode->cond);
     if (whilenode->cond->type != &builtin_types[TYPE_INFO_KIND_BOOL]) {
         onyx_message_add(state->msgs,
@@ -100,10 +100,10 @@ static void check_while(OnyxSemPassState* state, AstNodeWhile* whilenode) {
     check_block(state, whilenode->body);
 }
 
-static void check_call(OnyxSemPassState* state, AstNodeCall* call) {
-    AstNodeFunction* callee = (AstNodeFunction *) call->callee;
+static void check_call(OnyxSemPassState* state, AstCall* call) {
+    AstFunction* callee = (AstFunction *) call->callee;
 
-    if (callee->base.kind == AST_NODE_KIND_SYMBOL) {
+    if (callee->base.kind == Ast_Kind_Symbol) {
         onyx_message_add(state->msgs,
                 ONYX_MESSAGE_TYPE_UNRESOLVED_SYMBOL,
                 callee->base.token->pos,
@@ -111,7 +111,7 @@ static void check_call(OnyxSemPassState* state, AstNodeCall* call) {
         return;
     }
 
-    if (callee->base.kind != AST_NODE_KIND_FUNCTION) {
+    if (callee->base.kind != Ast_Kind_Function) {
         onyx_message_add(state->msgs,
                 ONYX_MESSAGE_TYPE_CALL_NON_FUNCTION,
                 call->base.token->pos,
@@ -121,8 +121,8 @@ static void check_call(OnyxSemPassState* state, AstNodeCall* call) {
 
     // NOTE: If we calling an intrinsic function, translate the
     // call into an intrinsic call node.
-    if (callee->base.flags & ONYX_AST_FLAG_INTRINSIC) {
-        call->base.kind = AST_NODE_KIND_INTRINSIC_CALL;
+    if (callee->base.flags & Ast_Flag_Intrinsic) {
+        call->base.kind = Ast_Kind_Intrinsic_Call;
         call->callee = NULL;
 
         onyx_token_null_toggle(callee->base.token);
@@ -177,19 +177,19 @@ static void check_call(OnyxSemPassState* state, AstNodeCall* call) {
         else if (!strcmp("max_f64", intr_name))      intrinsic = ONYX_INTRINSIC_F64_MAX;
         else if (!strcmp("copysign_f64", intr_name)) intrinsic = ONYX_INTRINSIC_F64_COPYSIGN;
 
-        ((AstNodeIntrinsicCall *)call)->intrinsic = intrinsic;
+        ((AstIntrinsicCall *)call)->intrinsic = intrinsic;
 
         onyx_token_null_toggle(callee->base.token);
     }
 
     call->base.type = callee->base.type;
 
-    AstNodeLocal* formal_param = callee->params;
-    AstNodeArgument* actual_param = call->arguments;
+    AstLocal* formal_param = callee->params;
+    AstArgument* actual_param = call->arguments;
 
     i32 arg_pos = 0;
     while (formal_param != NULL && actual_param != NULL) {
-        check_expression(state, (AstNodeTyped *) actual_param);
+        check_expression(state, (AstTyped *) actual_param);
 
         if (formal_param->base.type != actual_param->base.type) {
             onyx_message_add(state->msgs,
@@ -202,8 +202,8 @@ static void check_call(OnyxSemPassState* state, AstNodeCall* call) {
         }
 
         arg_pos++;
-        formal_param = (AstNodeLocal *) formal_param->base.next;
-        actual_param = (AstNodeArgument *) actual_param->base.next;
+        formal_param = (AstLocal *) formal_param->base.next;
+        actual_param = (AstArgument *) actual_param->base.next;
     }
 
     if (formal_param != NULL && actual_param == NULL) {
@@ -223,15 +223,15 @@ static void check_call(OnyxSemPassState* state, AstNodeCall* call) {
     }
 }
 
-static void check_expression(OnyxSemPassState* state, AstNodeTyped* expr) {
+static void check_expression(OnyxSemPassState* state, AstTyped* expr) {
     switch (expr->kind) {
-        case AST_NODE_KIND_BIN_OP:
+        case Ast_Kind_Binary_Op:
             expr->type = &builtin_types[TYPE_INFO_KIND_UNKNOWN];
 
-            check_expression(state, ((AstNodeBinOp *) expr)->left);
-            check_expression(state, ((AstNodeBinOp *) expr)->right);
+            check_expression(state, ((AstBinaryOp *) expr)->left);
+            check_expression(state, ((AstBinaryOp *) expr)->right);
 
-            if (((AstNodeBinOp *) expr)->left->type == NULL) {
+            if (((AstBinaryOp *) expr)->left->type == NULL) {
                 onyx_message_add(state->msgs,
                         ONYX_MESSAGE_TYPE_UNRESOLVED_TYPE,
                         expr->token->pos,
@@ -239,7 +239,7 @@ static void check_expression(OnyxSemPassState* state, AstNodeTyped* expr) {
                 return;
             }
 
-            if (((AstNodeBinOp *) expr)->right->type == NULL) {
+            if (((AstBinaryOp *) expr)->right->type == NULL) {
                 onyx_message_add(state->msgs,
                         ONYX_MESSAGE_TYPE_UNRESOLVED_TYPE,
                         expr->token->pos,
@@ -247,48 +247,48 @@ static void check_expression(OnyxSemPassState* state, AstNodeTyped* expr) {
                 return;
             }
 
-            if (((AstNodeBinOp *) expr)->left->type != ((AstNodeBinOp *) expr)->right->type) {
+            if (((AstBinaryOp *) expr)->left->type != ((AstBinaryOp *) expr)->right->type) {
                 onyx_message_add(state->msgs,
                         ONYX_MESSAGE_TYPE_BINOP_MISMATCH_TYPE,
                         expr->token->pos,
-                        ((AstNodeBinOp *) expr)->left->type->name,
-                        ((AstNodeBinOp *) expr)->right->type->name);
+                        ((AstBinaryOp *) expr)->left->type->name,
+                        ((AstBinaryOp *) expr)->right->type->name);
                 return;
             }
 
-            if (((AstNodeBinOp *) expr)->operation >= ONYX_BINARY_OP_EQUAL
-                    && ((AstNodeBinOp *) expr)->operation <= ONYX_BINARY_OP_GREATER_EQUAL) {
+            if (((AstBinaryOp *) expr)->operation >= Binary_Op_Equal
+                    && ((AstBinaryOp *) expr)->operation <= Binary_Op_Greater_Equal) {
                 expr->type = &builtin_types[TYPE_INFO_KIND_BOOL];
             } else {
-                expr->type = ((AstNodeBinOp *) expr)->left->type;
+                expr->type = ((AstBinaryOp *) expr)->left->type;
             }
 
             break;
 
-        case AST_NODE_KIND_UNARY_OP:
-            if (((AstNodeUnaryOp *) expr)->operation != ONYX_UNARY_OP_CAST) {
-                check_expression(state, ((AstNodeUnaryOp *) expr)->expr);
-                expr->type = ((AstNodeUnaryOp *) expr)->expr->type;
+        case Ast_Kind_Unary_Op:
+            if (((AstUnaryOp *) expr)->operation != Unary_Op_Cast) {
+                check_expression(state, ((AstUnaryOp *) expr)->expr);
+                expr->type = ((AstUnaryOp *) expr)->expr->type;
             }
             break;
 
-        case AST_NODE_KIND_CALL:
-            check_call(state, (AstNodeCall *) expr);
+        case Ast_Kind_Call:
+            check_call(state, (AstCall *) expr);
             break;
 
-        case AST_NODE_KIND_BLOCK:
-            check_block(state, (AstNodeBlock *) expr);
+        case Ast_Kind_Block:
+            check_block(state, (AstBlock *) expr);
             break;
 
-        case AST_NODE_KIND_SYMBOL:
+        case Ast_Kind_Symbol:
             onyx_message_add(state->msgs,
                     ONYX_MESSAGE_TYPE_UNRESOLVED_SYMBOL,
                     expr->token->pos,
                     expr->token->text, expr->token->length);
             break;
 
-        case AST_NODE_KIND_LOCAL:
-        case AST_NODE_KIND_PARAM:
+        case Ast_Kind_Local:
+        case Ast_Kind_Param:
             if (!expr->type->is_known) {
                 onyx_message_add(state->msgs,
                         ONYX_MESSAGE_TYPE_LITERAL,
@@ -297,7 +297,7 @@ static void check_expression(OnyxSemPassState* state, AstNodeTyped* expr) {
             }
             break;
 
-        case AST_NODE_KIND_GLOBAL:
+        case Ast_Kind_Global:
             if (!expr->type->is_known) {
                 onyx_message_add(state->msgs,
                         ONYX_MESSAGE_TYPE_LITERAL,
@@ -306,12 +306,12 @@ static void check_expression(OnyxSemPassState* state, AstNodeTyped* expr) {
             }
             break;
 
-        case AST_NODE_KIND_ARGUMENT:
-            check_expression(state, ((AstNodeArgument *) expr)->value);
-            expr->type = ((AstNodeArgument *) expr)->value->type;
+        case Ast_Kind_Argument:
+            check_expression(state, ((AstArgument *) expr)->value);
+            expr->type = ((AstArgument *) expr)->value->type;
             break;
 
-        case AST_NODE_KIND_LITERAL:
+        case Ast_Kind_Literal:
             // NOTE: Literal types should have been decided
             // in the parser (for now).
             assert(expr->type->is_known);
@@ -323,7 +323,7 @@ static void check_expression(OnyxSemPassState* state, AstNodeTyped* expr) {
     }
 }
 
-static void check_global(OnyxSemPassState* state, AstNodeGlobal* global) {
+static void check_global(OnyxSemPassState* state, AstGlobal* global) {
     if (global->initial_value) {
         check_expression(state, global->initial_value);
 
@@ -353,12 +353,12 @@ static void check_global(OnyxSemPassState* state, AstNodeGlobal* global) {
 
 static void check_statement(OnyxSemPassState* state, AstNode* stmt) {
     switch (stmt->kind) {
-        case AST_NODE_KIND_ASSIGNMENT: check_assignment(state, (AstNodeAssign *) stmt); break;
-        case AST_NODE_KIND_RETURN:     check_return(state, (AstNodeReturn *) stmt); break;
-        case AST_NODE_KIND_IF:         check_if(state, (AstNodeIf *) stmt); break;
-        case AST_NODE_KIND_WHILE:      check_while(state, (AstNodeWhile *) stmt); break;
-        case AST_NODE_KIND_CALL:       check_call(state, (AstNodeCall *) stmt); break;
-        case AST_NODE_KIND_BLOCK:      check_block(state, (AstNodeBlock *) stmt); break;
+        case Ast_Kind_Assignment: check_assignment(state, (AstAssign *) stmt); break;
+        case Ast_Kind_Return:     check_return(state, (AstReturn *) stmt); break;
+        case Ast_Kind_If:         check_if(state, (AstIf *) stmt); break;
+        case Ast_Kind_While:      check_while(state, (AstWhile *) stmt); break;
+        case Ast_Kind_Call:       check_call(state, (AstCall *) stmt); break;
+        case Ast_Kind_Block:      check_block(state, (AstBlock *) stmt); break;
 
         default: break;
     }
@@ -371,10 +371,10 @@ static void check_statement_chain(OnyxSemPassState* state, AstNode* start) {
     }
 }
 
-static void check_block(OnyxSemPassState* state, AstNodeBlock* block) {
+static void check_block(OnyxSemPassState* state, AstBlock* block) {
     check_statement_chain(state, block->body);
 
-    forll(AstNodeLocal, local, block->locals->last_local, prev_local) {
+    forll(AstLocal, local, block->locals->last_local, prev_local) {
         if (!local->base.type->is_known) {
             onyx_message_add(state->msgs,
                     ONYX_MESSAGE_TYPE_UNRESOLVED_TYPE,
@@ -385,8 +385,8 @@ static void check_block(OnyxSemPassState* state, AstNodeBlock* block) {
     }
 }
 
-static void check_function(OnyxSemPassState* state, AstNodeFunction* func) {
-    for (AstNodeLocal *param = func->params; param != NULL; param = (AstNodeLocal *) param->base.next) {
+static void check_function(OnyxSemPassState* state, AstFunction* func) {
+    for (AstLocal *param = func->params; param != NULL; param = (AstLocal *) param->base.next) {
         if (!param->base.type->is_known) {
             onyx_message_add(state->msgs,
                     ONYX_MESSAGE_TYPE_LITERAL,
@@ -412,9 +412,9 @@ static void check_function(OnyxSemPassState* state, AstNodeFunction* func) {
 
 void onyx_type_check(OnyxSemPassState* state, OnyxProgram* program) {
 
-    bh_arr_each(AstNodeGlobal *, global, program->globals)
+    bh_arr_each(AstGlobal *, global, program->globals)
         check_global(state, *global);
 
-    bh_arr_each(AstNodeFunction *, function, program->functions)
+    bh_arr_each(AstFunction *, function, program->functions)
         check_function(state, *function);
 }
diff --git a/src/onyxlex.c b/src/onyxlex.c
index ae206870..7d6eabaf 100644
--- a/src/onyxlex.c
+++ b/src/onyxlex.c
@@ -79,10 +79,10 @@ static b32 token_lit(OnyxTokenizer* tokenizer, OnyxToken* tk, char* lit, b32 is_
 }
 
 const char* onyx_get_token_type_name(TokenType tkn_type) {
-    if (tkn_type < TOKEN_TYPE_ASCII_END) {
+    if (tkn_type < Token_Type_Ascii_End) {
         return bh_aprintf(global_scratch_allocator, "%c", (char) tkn_type);
     } else {
-        return token_type_names[tkn_type - TOKEN_TYPE_ASCII_END];
+        return token_type_names[tkn_type - Token_Type_Ascii_End];
     }
 }
 
@@ -100,7 +100,7 @@ OnyxToken* onyx_get_token(OnyxTokenizer* tokenizer) {
     while (char_is_whitespace(*tokenizer->curr) && tokenizer->curr != tokenizer->end)
         INCREMENT_CURR_TOKEN(tokenizer)
 
-    tk.type = TOKEN_TYPE_UNKNOWN;
+    tk.type = Token_Type_Unknown;
     tk.text = tokenizer->curr;
     tk.length = 1;
     tk.pos.line_start = tokenizer->line_start;
@@ -109,14 +109,14 @@ OnyxToken* onyx_get_token(OnyxTokenizer* tokenizer) {
     tk.pos.column = (i32)(tokenizer->curr - tokenizer->line_start) + 1;
 
     if (tokenizer->curr == tokenizer->end) {
-        tk.type = TOKEN_TYPE_END_STREAM;
+        tk.type = Token_Type_End_Stream;
         goto token_parsed;
     }
 
     // Comments
     if (*tokenizer->curr == '/' && *(tokenizer->curr + 1) == '/') {
         tokenizer->curr += 2;
-        tk.type = TOKEN_TYPE_COMMENT;
+        tk.type = Token_Type_Comment;
         tk.text = tokenizer->curr;
 
         while (*tokenizer->curr != '\n') {
@@ -127,32 +127,32 @@ OnyxToken* onyx_get_token(OnyxTokenizer* tokenizer) {
         goto token_parsed;
     }
 
-    LITERAL_TOKEN("struct",     1, TOKEN_TYPE_KEYWORD_STRUCT);
-    LITERAL_TOKEN("export",     1, TOKEN_TYPE_KEYWORD_EXPORT);
-    LITERAL_TOKEN("use",        1, TOKEN_TYPE_KEYWORD_USE);
-    LITERAL_TOKEN("if",         1, TOKEN_TYPE_KEYWORD_IF);
-    LITERAL_TOKEN("elseif",     1, TOKEN_TYPE_KEYWORD_ELSEIF);
-    LITERAL_TOKEN("else",       1, TOKEN_TYPE_KEYWORD_ELSE);
-    LITERAL_TOKEN("foreign",    1, TOKEN_TYPE_KEYWORD_FOREIGN);
-    LITERAL_TOKEN("return",     1, TOKEN_TYPE_KEYWORD_RETURN);
-    LITERAL_TOKEN("proc",       1, TOKEN_TYPE_KEYWORD_PROC);
-    LITERAL_TOKEN("as",         1, TOKEN_TYPE_KEYWORD_CAST);
-    LITERAL_TOKEN("while",      1, TOKEN_TYPE_KEYWORD_WHILE);
-    LITERAL_TOKEN("break",      1, TOKEN_TYPE_KEYWORD_BREAK);
-    LITERAL_TOKEN("continue",   1, TOKEN_TYPE_KEYWORD_CONTINUE);
-    LITERAL_TOKEN("true",       1, TOKEN_TYPE_LITERAL_BOOL_TRUE);
-    LITERAL_TOKEN("false",      1, TOKEN_TYPE_LITERAL_BOOL_FALSE);
-    LITERAL_TOKEN("->",         0, TOKEN_TYPE_RIGHT_ARROW);
-    LITERAL_TOKEN("<-",         0, TOKEN_TYPE_RIGHT_ARROW);
-    LITERAL_TOKEN("<=",         0, TOKEN_TYPE_LESS_EQUAL);
-    LITERAL_TOKEN(">=",         0, TOKEN_TYPE_GREATER_EQUAL);
-    LITERAL_TOKEN("==",         0, TOKEN_TYPE_EQUAL_EQUAL);
-    LITERAL_TOKEN("!=",         0, TOKEN_TYPE_NOT_EQUAL);
-    LITERAL_TOKEN("+=",         0, TOKEN_TYPE_PLUS_EQUAL);
-    LITERAL_TOKEN("-=",         0, TOKEN_TYPE_MINUS_EQUAL);
-    LITERAL_TOKEN("*=",         0, TOKEN_TYPE_STAR_EQUAL);
-    LITERAL_TOKEN("/=",         0, TOKEN_TYPE_FSLASH_EQUAL);
-    LITERAL_TOKEN("%=",         0, TOKEN_TYPE_PERCENT_EQUAL);
+    LITERAL_TOKEN("struct",     1, Token_Type_Keyword_Struct);
+    LITERAL_TOKEN("export",     1, Token_Type_Keyword_Export);
+    LITERAL_TOKEN("use",        1, Token_Type_Keyword_Use);
+    LITERAL_TOKEN("if",         1, Token_Type_Keyword_If);
+    LITERAL_TOKEN("elseif",     1, Token_Type_Keyword_Elseif);
+    LITERAL_TOKEN("else",       1, Token_Type_Keyword_Else);
+    LITERAL_TOKEN("foreign",    1, Token_Type_Keyword_Foreign);
+    LITERAL_TOKEN("return",     1, Token_Type_Keyword_Return);
+    LITERAL_TOKEN("proc",       1, Token_Type_Keyword_Proc);
+    LITERAL_TOKEN("as",         1, Token_Type_Keyword_Cast);
+    LITERAL_TOKEN("while",      1, Token_Type_Keyword_While);
+    LITERAL_TOKEN("break",      1, Token_Type_Keyword_Break);
+    LITERAL_TOKEN("continue",   1, Token_Type_Keyword_Continue);
+    LITERAL_TOKEN("true",       1, Token_Type_Literal_True);
+    LITERAL_TOKEN("false",      1, Token_Type_Literal_False);
+    LITERAL_TOKEN("->",         0, Token_Type_Right_Arrow);
+    LITERAL_TOKEN("<-",         0, Token_Type_Right_Arrow);
+    LITERAL_TOKEN("<=",         0, Token_Type_Less_Equal);
+    LITERAL_TOKEN(">=",         0, Token_Type_Greater_Equal);
+    LITERAL_TOKEN("==",         0, Token_Type_Equal_Equal);
+    LITERAL_TOKEN("!=",         0, Token_Type_Not_Equal);
+    LITERAL_TOKEN("+=",         0, Token_Type_Plus_Equal);
+    LITERAL_TOKEN("-=",         0, Token_Type_Minus_Equal);
+    LITERAL_TOKEN("*=",         0, Token_Type_Star_Equal);
+    LITERAL_TOKEN("/=",         0, Token_Type_Fslash_Equal);
+    LITERAL_TOKEN("%=",         0, Token_Type_Percent_Equal);
 
     // Symbols
     if (char_is_alpha(*tk.text)) {
@@ -163,7 +163,7 @@ OnyxToken* onyx_get_token(OnyxTokenizer* tokenizer) {
         }
 
         tk.length = len;
-        tk.type = TOKEN_TYPE_SYMBOL;
+        tk.type = Token_Type_Symbol;
         goto token_parsed;
     }
 
@@ -190,7 +190,7 @@ OnyxToken* onyx_get_token(OnyxTokenizer* tokenizer) {
         INCREMENT_CURR_TOKEN(tokenizer);
 
         tk.text++;
-        tk.type = TOKEN_TYPE_LITERAL_STRING;
+        tk.type = Token_Type_Literal_String;
         tk.length = len;
         goto token_parsed;
     }
@@ -208,7 +208,7 @@ OnyxToken* onyx_get_token(OnyxTokenizer* tokenizer) {
             INCREMENT_CURR_TOKEN(tokenizer);
         }
 
-        tk.type = TOKEN_TYPE_LITERAL_NUMERIC;
+        tk.type = Token_Type_Literal_Numeric;
         tk.length = len;
 
         INCREMENT_CURR_TOKEN(tokenizer);
@@ -249,5 +249,5 @@ void onyx_lex_tokens(OnyxTokenizer* tokenizer) {
     OnyxToken* tk;
     do {
         tk = onyx_get_token(tokenizer);
-    } while (tk->type != TOKEN_TYPE_END_STREAM);
+    } while (tk->type != Token_Type_End_Stream);
 }
diff --git a/src/onyxparser.c b/src/onyxparser.c
index 260217a7..0f5fb536 100644
--- a/src/onyxparser.c
+++ b/src/onyxparser.c
@@ -25,36 +25,36 @@ struct TypeInfo builtin_types[] = {
     { 0xffffffff } // Sentinel
 };
 
-static AstNode error_node = { AST_NODE_KIND_ERROR, 0, NULL, NULL };
+static AstNode error_node = { Ast_Kind_Error, 0, NULL, NULL };
 
 // NOTE: Forward declarations
 static void parser_next_token(OnyxParser* parser);
 static void parser_prev_token(OnyxParser* parser);
 static b32 is_terminating_token(TokenType token_type);
 static OnyxToken* expect(OnyxParser* parser, TokenType token_type);
-static AstNodeNumLit* parse_numeric_literal(OnyxParser* parser);
-static AstNodeTyped* parse_factor(OnyxParser* parser);
-static AstNodeTyped* parse_expression(OnyxParser* parser);
-static AstNodeIf* parse_if_stmt(OnyxParser* parser);
-static AstNodeWhile* parse_while_stmt(OnyxParser* parser);
+static AstNumLit* parse_numeric_literal(OnyxParser* parser);
+static AstTyped* parse_factor(OnyxParser* parser);
+static AstTyped* parse_expression(OnyxParser* parser);
+static AstIf* parse_if_stmt(OnyxParser* parser);
+static AstWhile* parse_while_stmt(OnyxParser* parser);
 static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret);
-static AstNodeReturn* parse_return_statement(OnyxParser* parser);
-static AstNodeBlock* parse_block(OnyxParser* parser);
+static AstReturn* parse_return_statement(OnyxParser* parser);
+static AstBlock* parse_block(OnyxParser* parser);
 static AstNode* parse_statement(OnyxParser* parser);
-static TypeInfo* parse_type(OnyxParser* parser);
-static AstNodeLocal* parse_function_params(OnyxParser* parser);
-static AstNodeFunction* parse_function_definition(OnyxParser* parser);
+static AstNode* parse_type(OnyxParser* parser);
+static AstLocal* parse_function_params(OnyxParser* parser);
+static AstFunction* parse_function_definition(OnyxParser* parser);
 static AstNode* parse_top_level_statement(OnyxParser* parser);
 
 static void parser_next_token(OnyxParser* parser) {
     parser->prev_token = parser->curr_token;
     parser->curr_token++;
-    while (parser->curr_token->type == TOKEN_TYPE_COMMENT) parser->curr_token++;
+    while (parser->curr_token->type == Token_Type_Comment) parser->curr_token++;
 }
 
 static void parser_prev_token(OnyxParser* parser) {
     // TODO: This is probably wrong
-    while (parser->prev_token->type == TOKEN_TYPE_COMMENT) parser->prev_token--;
+    while (parser->prev_token->type == Token_Type_Comment) parser->prev_token--;
     parser->curr_token = parser->prev_token;
     parser->prev_token--;
 }
@@ -63,7 +63,7 @@ static b32 is_terminating_token(TokenType token_type) {
     return (token_type == ';')
         || (token_type == '}')
         || (token_type == '{')
-        || (token_type == TOKEN_TYPE_END_STREAM);
+        || (token_type == Token_Type_End_Stream);
 }
 
 static void find_token(OnyxParser* parser, TokenType token_type) {
@@ -88,10 +88,10 @@ static OnyxToken* expect(OnyxParser* parser, TokenType token_type) {
     return token;
 }
 
-static AstNodeNumLit* parse_numeric_literal(OnyxParser* parser) {
-    AstNodeNumLit* lit_node = make_node(AstNodeNumLit, AST_NODE_KIND_LITERAL);
-    lit_node->base.token = expect(parser, TOKEN_TYPE_LITERAL_NUMERIC);
-    lit_node->base.flags |= ONYX_AST_FLAG_COMPTIME;
+static AstNumLit* parse_numeric_literal(OnyxParser* parser) {
+    AstNumLit* lit_node = make_node(AstNumLit, Ast_Kind_Literal);
+    lit_node->base.token = expect(parser, Token_Type_Literal_Numeric);
+    lit_node->base.flags |= Ast_Flag_Comptime;
     lit_node->value.l = 0ll;
 
     onyx_token_null_toggle(lit_node->base.token);
@@ -125,14 +125,14 @@ static AstNodeNumLit* parse_numeric_literal(OnyxParser* parser) {
     return lit_node;
 }
 
-static AstNodeTyped* parse_factor(OnyxParser* parser) {
-    AstNodeTyped* retval = NULL;
+static AstTyped* parse_factor(OnyxParser* parser) {
+    AstTyped* retval = NULL;
 
     switch ((u16) parser->curr_token->type) {
         case '(':
             {
                 parser_next_token(parser);
-                AstNodeTyped* expr = parse_expression(parser);
+                AstTyped* expr = parse_expression(parser);
                 expect(parser, ')');
                 retval = expr;
                 break;
@@ -141,24 +141,24 @@ static AstNodeTyped* parse_factor(OnyxParser* parser) {
         case '-':
             {
                 parser_next_token(parser);
-                AstNodeTyped* factor = parse_factor(parser);
+                AstTyped* factor = parse_factor(parser);
 
-                AstNodeUnaryOp* negate_node = make_node(AstNodeUnaryOp, AST_NODE_KIND_UNARY_OP);
-                negate_node->operation = ONYX_UNARY_OP_NEGATE;
+                AstUnaryOp* negate_node = make_node(AstUnaryOp, Ast_Kind_Unary_Op);
+                negate_node->operation = Unary_Op_Negate;
                 negate_node->expr = factor;
 
-                if ((factor->flags & ONYX_AST_FLAG_COMPTIME) != 0) {
-                    negate_node->base.flags |= ONYX_AST_FLAG_COMPTIME;
+                if ((factor->flags & Ast_Flag_Comptime) != 0) {
+                    negate_node->base.flags |= Ast_Flag_Comptime;
                 }
 
-                retval = (AstNodeTyped *) negate_node;
+                retval = (AstTyped *) negate_node;
                 break;
             }
 
-        case TOKEN_TYPE_SYMBOL:
+        case Token_Type_Symbol:
             {
-                OnyxToken* sym_token = expect(parser, TOKEN_TYPE_SYMBOL);
-                AstNodeTyped* sym_node = make_node(AstNode, AST_NODE_KIND_SYMBOL);
+                OnyxToken* sym_token = expect(parser, Token_Type_Symbol);
+                AstTyped* sym_node = make_node(AstTyped, Ast_Kind_Symbol);
                 sym_node->token = sym_token;
 
                 if (parser->curr_token->type != '(') {
@@ -167,19 +167,19 @@ static AstNodeTyped* parse_factor(OnyxParser* parser) {
                 }
 
                 // NOTE: Function call
-                AstNodeCall* call_node = make_node(AstNodeCall, AST_NODE_KIND_CALL);
+                AstCall* call_node = make_node(AstCall, Ast_Kind_Call);
                 call_node->base.token = expect(parser, '(');
                 call_node->callee = (AstNode *) sym_node;
 
-                AstNodeArgument** prev = &call_node->arguments;
-                AstNodeArgument* curr = NULL;
+                AstArgument** prev = &call_node->arguments;
+                AstArgument* curr = NULL;
                 while (parser->curr_token->type != ')') {
-                    curr = make_node(AstNodeArgument, AST_NODE_KIND_ARGUMENT);
+                    curr = make_node(AstArgument, Ast_Kind_Argument);
                     curr->value = parse_expression(parser);
 
-                    if (curr != NULL && curr->base.kind != AST_NODE_KIND_ERROR) {
+                    if (curr != NULL && curr->base.kind != Ast_Kind_Error) {
                         *prev = curr;
-                        prev = (AstNodeArgument **) &curr->base.next;
+                        prev = (AstArgument **) &curr->base.next;
                     }
 
                     if (parser->curr_token->type == ')')
@@ -191,38 +191,38 @@ static AstNodeTyped* parse_factor(OnyxParser* parser) {
                                 parser->curr_token->pos,
                                 onyx_get_token_type_name(','),
                                 onyx_get_token_type_name(parser->curr_token->type));
-                        return (AstNodeTyped *) &error_node;
+                        return (AstTyped *) &error_node;
                     }
 
                     parser_next_token(parser);
                 }
                 parser_next_token(parser);
 
-                retval = (AstNodeTyped *) call_node;
+                retval = (AstTyped *) call_node;
                 break;
             }
 
-        case TOKEN_TYPE_LITERAL_NUMERIC:
-            retval = (AstNodeTyped *) parse_numeric_literal(parser);
+        case Token_Type_Literal_Numeric:
+            retval = (AstTyped *) parse_numeric_literal(parser);
             break;
 
-        case TOKEN_TYPE_LITERAL_BOOL_TRUE:
+        case Token_Type_Literal_True:
             {
-                AstNodeNumLit* bool_node = make_node(AstNodeNumLit, AST_NODE_KIND_LITERAL);
+                AstNumLit* bool_node = make_node(AstNumLit, Ast_Kind_Literal);
                 bool_node->base.type = &builtin_types[TYPE_INFO_KIND_BOOL];
-                bool_node->base.token = expect(parser, TOKEN_TYPE_LITERAL_BOOL_TRUE);
+                bool_node->base.token = expect(parser, Token_Type_Literal_True);
                 bool_node->value.i = 1;
-                retval = (AstNodeTyped *) bool_node;
+                retval = (AstTyped *) bool_node;
                 break;
             }
 
-        case TOKEN_TYPE_LITERAL_BOOL_FALSE:
+        case Token_Type_Literal_False:
             {
-                AstNodeNumLit* bool_node = make_node(AstNodeNumLit, AST_NODE_KIND_LITERAL);
+                AstNumLit* bool_node = make_node(AstNumLit, Ast_Kind_Literal);
                 bool_node->base.type = &builtin_types[TYPE_INFO_KIND_BOOL];
-                bool_node->base.token = expect(parser, TOKEN_TYPE_LITERAL_BOOL_FALSE);
+                bool_node->base.token = expect(parser, Token_Type_Literal_False);
                 bool_node->value.i = 0;
-                retval = (AstNodeTyped *) bool_node;
+                retval = (AstTyped *) bool_node;
                 break;
             }
 
@@ -234,67 +234,67 @@ static AstNodeTyped* parse_factor(OnyxParser* parser) {
             return NULL;
     }
 
-    if (parser->curr_token->type == TOKEN_TYPE_KEYWORD_CAST) {
+    if (parser->curr_token->type == Token_Type_Keyword_Cast) {
         parser_next_token(parser);
 
-        AstNodeUnaryOp* cast_node = make_node(AstNodeUnaryOp, AST_NODE_KIND_UNARY_OP);
+        AstUnaryOp* cast_node = make_node(AstUnaryOp, Ast_Kind_Unary_Op);
         cast_node->base.type = parse_type(parser);
-        cast_node->operation = ONYX_UNARY_OP_CAST;
+        cast_node->operation = Unary_Op_Cast;
         cast_node->expr = retval;
-        retval = (AstNodeTyped *) cast_node;
+        retval = (AstTyped *) cast_node;
     }
 
     return retval;
 }
 
-static inline i32 get_precedence(OnyxBinaryOp kind) {
+static inline i32 get_precedence(BinaryOp kind) {
     switch (kind) {
-        case ONYX_BINARY_OP_EQUAL: return 3;
-        case ONYX_BINARY_OP_NOT_EQUAL: return 3;
+        case Binary_Op_Equal: return 3;
+        case Binary_Op_Not_Equal: return 3;
 
-        case ONYX_BINARY_OP_LESS_EQUAL: return 4;
-        case ONYX_BINARY_OP_LESS: return 4;
-        case ONYX_BINARY_OP_GREATER_EQUAL: return 4;
-        case ONYX_BINARY_OP_GREATER: return 4;
+        case Binary_Op_Less_Equal: return 4;
+        case Binary_Op_Less: return 4;
+        case Binary_Op_Greater_Equal: return 4;
+        case Binary_Op_Greater: return 4;
 
-        case ONYX_BINARY_OP_ADD: return 5;
-        case ONYX_BINARY_OP_MINUS: return 5;
+        case Binary_Op_Add: return 5;
+        case Binary_Op_Minus: return 5;
 
-        case ONYX_BINARY_OP_MULTIPLY: return 6;
-        case ONYX_BINARY_OP_DIVIDE: return 6;
+        case Binary_Op_Multiply: return 6;
+        case Binary_Op_Divide: return 6;
 
-        case ONYX_BINARY_OP_MODULUS: return 7;
+        case Binary_Op_Modulus: return 7;
         default: return -1;
     }
 }
 
-static AstNodeTyped* parse_expression(OnyxParser* parser) {
-    bh_arr(AstNodeBinOp*) tree_stack = NULL;
+static AstTyped* parse_expression(OnyxParser* parser) {
+    bh_arr(AstBinaryOp*) tree_stack = NULL;
     bh_arr_new(global_scratch_allocator, tree_stack, 4);
     bh_arr_set_length(tree_stack, 0);
 
-    AstNodeTyped* left = parse_factor(parser);
-    AstNodeTyped* right;
-    AstNodeTyped* root = left;
+    AstTyped* left = parse_factor(parser);
+    AstTyped* right;
+    AstTyped* root = left;
 
-    OnyxBinaryOp bin_op_kind;
+    BinaryOp bin_op_kind;
     OnyxToken* bin_op_tok;
 
     while (1) {
         bin_op_kind = -1;
         switch ((u16) parser->curr_token->type) {
-            case TOKEN_TYPE_EQUAL_EQUAL:    bin_op_kind = ONYX_BINARY_OP_EQUAL; break;
-            case TOKEN_TYPE_NOT_EQUAL:      bin_op_kind = ONYX_BINARY_OP_NOT_EQUAL; break;
-            case TOKEN_TYPE_LESS_EQUAL:     bin_op_kind = ONYX_BINARY_OP_LESS_EQUAL; break;
-            case TOKEN_TYPE_GREATER_EQUAL:  bin_op_kind = ONYX_BINARY_OP_GREATER_EQUAL; break;
-            case '<':                       bin_op_kind = ONYX_BINARY_OP_LESS; break;
-            case '>':                       bin_op_kind = ONYX_BINARY_OP_GREATER; break;
-
-            case '+':                       bin_op_kind = ONYX_BINARY_OP_ADD; break;
-            case '-':                       bin_op_kind = ONYX_BINARY_OP_MINUS; break;
-            case '*':                       bin_op_kind = ONYX_BINARY_OP_MULTIPLY; break;
-            case '/':                       bin_op_kind = ONYX_BINARY_OP_DIVIDE; break;
-            case '%':                       bin_op_kind = ONYX_BINARY_OP_MODULUS; break;
+            case Token_Type_Equal_Equal:    bin_op_kind = Binary_Op_Equal; break;
+            case Token_Type_Not_Equal:      bin_op_kind = Binary_Op_Not_Equal; break;
+            case Token_Type_Less_Equal:     bin_op_kind = Binary_Op_Less_Equal; break;
+            case Token_Type_Greater_Equal:  bin_op_kind = Binary_Op_Greater_Equal; break;
+            case '<':                       bin_op_kind = Binary_Op_Less; break;
+            case '>':                       bin_op_kind = Binary_Op_Greater; break;
+
+            case '+':                       bin_op_kind = Binary_Op_Add; break;
+            case '-':                       bin_op_kind = Binary_Op_Minus; break;
+            case '*':                       bin_op_kind = Binary_Op_Multiply; break;
+            case '/':                       bin_op_kind = Binary_Op_Divide; break;
+            case '%':                       bin_op_kind = Binary_Op_Modulus; break;
             default: goto expression_done;
         }
 
@@ -302,7 +302,7 @@ static AstNodeTyped* parse_expression(OnyxParser* parser) {
             bin_op_tok = parser->curr_token;
             parser_next_token(parser);
 
-            AstNodeBinOp* bin_op = make_node(AstNodeBinOp, AST_NODE_KIND_BIN_OP);
+            AstBinaryOp* bin_op = make_node(AstBinaryOp, Ast_Kind_Binary_Op);
             bin_op->operation = bin_op_kind;
             bin_op->base.token = bin_op_tok;
 
@@ -313,10 +313,10 @@ static AstNodeTyped* parse_expression(OnyxParser* parser) {
             if (bh_arr_is_empty(tree_stack)) {
                 // NOTE: new is now the root node
                 bin_op->left = root;
-                root = (AstNodeTyped *) bin_op;
+                root = (AstTyped *) bin_op;
             } else {
                 bin_op->left = bh_arr_last(tree_stack)->right;
-                bh_arr_last(tree_stack)->right = (AstNodeTyped *) bin_op;
+                bh_arr_last(tree_stack)->right = (AstTyped *) bin_op;
             }
 
             bh_arr_push(tree_stack, bin_op);
@@ -324,8 +324,8 @@ static AstNodeTyped* parse_expression(OnyxParser* parser) {
             right = parse_factor(parser);
             bin_op->right = right;
 
-            if ((left->flags & ONYX_AST_FLAG_COMPTIME) != 0 && (right->flags & ONYX_AST_FLAG_COMPTIME) != 0) {
-                bin_op->base.flags |= ONYX_AST_FLAG_COMPTIME;
+            if ((left->flags & Ast_Flag_Comptime) != 0 && (right->flags & Ast_Flag_Comptime) != 0) {
+                bin_op->base.flags |= Ast_Flag_Comptime;
             }
         }
     }
@@ -334,22 +334,22 @@ expression_done:
     return root;
 }
 
-static AstNodeIf* parse_if_stmt(OnyxParser* parser) {
-    expect(parser, TOKEN_TYPE_KEYWORD_IF);
+static AstIf* parse_if_stmt(OnyxParser* parser) {
+    expect(parser, Token_Type_Keyword_If);
 
-    AstNodeTyped* cond = parse_expression(parser);
-    AstNodeBlock* true_block = parse_block(parser);
+    AstTyped* cond = parse_expression(parser);
+    AstBlock* true_block = parse_block(parser);
 
-    AstNodeIf* if_node = make_node(AstNodeIf, AST_NODE_KIND_IF);
-    AstNodeIf* root_if = if_node;
+    AstIf* if_node = make_node(AstIf, Ast_Kind_If);
+    AstIf* root_if = if_node;
 
     if_node->cond = cond;
     if (true_block != NULL)
         if_node->true_block.as_block = true_block;
 
-    while (parser->curr_token->type == TOKEN_TYPE_KEYWORD_ELSEIF) {
+    while (parser->curr_token->type == Token_Type_Keyword_Elseif) {
         parser_next_token(parser);
-        AstNodeIf* elseif_node = make_node(AstNodeIf, AST_NODE_KIND_IF);
+        AstIf* elseif_node = make_node(AstIf, Ast_Kind_If);
 
         cond = parse_expression(parser);
         true_block = parse_block(parser);
@@ -362,10 +362,10 @@ static AstNodeIf* parse_if_stmt(OnyxParser* parser) {
         if_node = elseif_node;
     }
 
-    if (parser->curr_token->type == TOKEN_TYPE_KEYWORD_ELSE) {
+    if (parser->curr_token->type == Token_Type_Keyword_Else) {
         parser_next_token(parser);
 
-        AstNodeBlock* false_block = parse_block(parser);
+        AstBlock* false_block = parse_block(parser);
         if (false_block != NULL)
             if_node->false_block.as_block = false_block;
     }
@@ -373,13 +373,13 @@ static AstNodeIf* parse_if_stmt(OnyxParser* parser) {
     return root_if;
 }
 
-static AstNodeWhile* parse_while_stmt(OnyxParser* parser) {
-    OnyxToken* while_token = expect(parser, TOKEN_TYPE_KEYWORD_WHILE);
+static AstWhile* parse_while_stmt(OnyxParser* parser) {
+    OnyxToken* while_token = expect(parser, Token_Type_Keyword_While);
 
-    AstNodeTyped* cond = parse_expression(parser);
-    AstNodeBlock* body = parse_block(parser);
+    AstTyped* cond = parse_expression(parser);
+    AstBlock* body = parse_block(parser);
 
-    AstNodeWhile* while_node = make_node(AstNodeWhile, AST_NODE_KIND_WHILE);
+    AstWhile* while_node = make_node(AstWhile, Ast_Kind_While);
     while_node->base.token = while_token;
     while_node->cond = cond;
     while_node->body = body;
@@ -390,8 +390,8 @@ static AstNodeWhile* parse_while_stmt(OnyxParser* parser) {
 // Returns 1 if the symbol was consumed. Returns 0 otherwise
 // ret is set to the statement to insert
 static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) {
-    if (parser->curr_token->type != TOKEN_TYPE_SYMBOL) return 0;
-    OnyxToken* symbol = expect(parser, TOKEN_TYPE_SYMBOL);
+    if (parser->curr_token->type != Token_Type_Symbol) return 0;
+    OnyxToken* symbol = expect(parser, Token_Type_Symbol);
 
     switch ((u16) parser->curr_token->type) {
         // NOTE: Declaration
@@ -401,27 +401,27 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) {
                 TypeInfo* type = &builtin_types[TYPE_INFO_KIND_UNKNOWN];
 
                 // NOTE: var: type
-                if (parser->curr_token->type == TOKEN_TYPE_SYMBOL) {
+                if (parser->curr_token->type == Token_Type_Symbol) {
                     type = parse_type(parser);
                 }
 
-                AstNodeLocal* local = make_node(AstNodeLocal, AST_NODE_KIND_LOCAL);
+                AstLocal* local = make_node(AstLocal, Ast_Kind_Local);
                 local->base.token = symbol;
                 local->base.type = type;
-                local->base.flags |= ONYX_AST_FLAG_LVAL; // NOTE: DELETE
+                local->base.flags |= Ast_Flag_Lval; // NOTE: DELETE
                 *ret = (AstNode *) local;
 
                 if (parser->curr_token->type == '=' || parser->curr_token->type == ':') {
                     if (parser->curr_token->type == ':') {
-                        local->base.flags |= ONYX_AST_FLAG_CONST;
+                        local->base.flags |= Ast_Flag_Const;
                     }
 
-                    AstNodeAssign* assignment = make_node(AstNodeAssign, AST_NODE_KIND_ASSIGNMENT);
+                    AstAssign* assignment = make_node(AstAssign, Ast_Kind_Assignment);
                     local->base.next = (AstNode *) assignment;
                     assignment->base.token = parser->curr_token;
                     parser_next_token(parser);
 
-                    AstNodeTyped* expr = parse_expression(parser);
+                    AstTyped* expr = parse_expression(parser);
                     if (expr == NULL) {
                         onyx_token_null_toggle(parser->curr_token);
                         onyx_message_add(parser->msgs,
@@ -433,9 +433,9 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) {
                     }
                     assignment->expr = expr;
 
-                    AstNode* left_symbol = make_node(AstNode, AST_NODE_KIND_SYMBOL);
+                    AstNode* left_symbol = make_node(AstNode, Ast_Kind_Symbol);
                     left_symbol->token = symbol;
-                    assignment->lval = (AstNodeTyped *) left_symbol;
+                    assignment->lval = (AstTyped *) left_symbol;
                 }
                 return 1;
             }
@@ -443,52 +443,52 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) {
             // NOTE: Assignment
         case '=':
             {
-                AstNodeAssign* assignment = make_node(AstNodeAssign, AST_NODE_KIND_ASSIGNMENT);
+                AstAssign* assignment = make_node(AstAssign, Ast_Kind_Assignment);
                 assignment->base.token = parser->curr_token;
                 parser_next_token(parser);
 
-                AstNode* lval = make_node(AstNode, AST_NODE_KIND_SYMBOL);
+                AstNode* lval = make_node(AstNode, Ast_Kind_Symbol);
                 lval->token = symbol;
 
-                AstNodeTyped* rval = parse_expression(parser);
+                AstTyped* rval = parse_expression(parser);
                 assignment->expr = rval;
-                assignment->lval = (AstNodeTyped *) lval;
+                assignment->lval = (AstTyped *) lval;
                 *ret = (AstNode *) assignment;
                 return 1;
             }
 
-        case TOKEN_TYPE_PLUS_EQUAL:
-        case TOKEN_TYPE_MINUS_EQUAL:
-        case TOKEN_TYPE_STAR_EQUAL:
-        case TOKEN_TYPE_FSLASH_EQUAL:
-        case TOKEN_TYPE_PERCENT_EQUAL:
+        case Token_Type_Plus_Equal:
+        case Token_Type_Minus_Equal:
+        case Token_Type_Star_Equal:
+        case Token_Type_Fslash_Equal:
+        case Token_Type_Percent_Equal:
             {
-                OnyxBinaryOp bin_op;
-                if      (parser->curr_token->type == TOKEN_TYPE_PLUS_EQUAL)    bin_op = ONYX_BINARY_OP_ADD;
-                else if (parser->curr_token->type == TOKEN_TYPE_MINUS_EQUAL)   bin_op = ONYX_BINARY_OP_MINUS;
-                else if (parser->curr_token->type == TOKEN_TYPE_STAR_EQUAL)    bin_op = ONYX_BINARY_OP_MULTIPLY;
-                else if (parser->curr_token->type == TOKEN_TYPE_FSLASH_EQUAL)  bin_op = ONYX_BINARY_OP_DIVIDE;
-                else if (parser->curr_token->type == TOKEN_TYPE_PERCENT_EQUAL) bin_op = ONYX_BINARY_OP_MODULUS;
+                BinaryOp bin_op;
+                if      (parser->curr_token->type == Token_Type_Plus_Equal)    bin_op = Binary_Op_Add;
+                else if (parser->curr_token->type == Token_Type_Minus_Equal)   bin_op = Binary_Op_Minus;
+                else if (parser->curr_token->type == Token_Type_Star_Equal)    bin_op = Binary_Op_Multiply;
+                else if (parser->curr_token->type == Token_Type_Fslash_Equal)  bin_op = Binary_Op_Divide;
+                else if (parser->curr_token->type == Token_Type_Percent_Equal) bin_op = Binary_Op_Modulus;
 
                 parser_next_token(parser);
 
-                AstNodeTyped* expr = parse_expression(parser);
+                AstTyped* expr = parse_expression(parser);
 
-                AstNodeBinOp* bin_op_node = make_node(AstNodeBinOp, AST_NODE_KIND_BIN_OP);
+                AstBinaryOp* bin_op_node = make_node(AstBinaryOp, Ast_Kind_Binary_Op);
                 bin_op_node->operation = bin_op;
 
-                AstNode* bin_op_left = make_node(AstNode, AST_NODE_KIND_SYMBOL);
+                AstNode* bin_op_left = make_node(AstNode, Ast_Kind_Symbol);
                 bin_op_left->token = symbol;
-                bin_op_node->left = (AstNodeTyped *) bin_op_left;
+                bin_op_node->left = (AstTyped *) bin_op_left;
                 bin_op_node->right = expr;
 
-                AstNodeAssign* assign_node = make_node(AstNodeAssign, AST_NODE_KIND_ASSIGNMENT);
+                AstAssign* assign_node = make_node(AstAssign, Ast_Kind_Assignment);
 
                 // TODO: Maybe I don't need to make another lval node?
-                AstNode* lval = make_node(AstNode, AST_NODE_KIND_SYMBOL);
+                AstNode* lval = make_node(AstNode, Ast_Kind_Symbol);
                 lval->token = symbol;
-                assign_node->lval = (AstNodeTyped *) lval;
-                assign_node->expr = (AstNodeTyped *) bin_op_node;
+                assign_node->lval = (AstTyped *) lval;
+                assign_node->expr = (AstTyped *) bin_op_node;
 
                 *ret = (AstNode *) assign_node;
 
@@ -502,17 +502,17 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) {
     return 0;
 }
 
-static AstNodeReturn* parse_return_statement(OnyxParser* parser) {
-    AstNodeReturn* return_node = make_node(AstNodeReturn, AST_NODE_KIND_RETURN);
-    return_node->base.token = expect(parser, TOKEN_TYPE_KEYWORD_RETURN);
+static AstReturn* parse_return_statement(OnyxParser* parser) {
+    AstReturn* return_node = make_node(AstReturn, Ast_Kind_Return);
+    return_node->base.token = expect(parser, Token_Type_Keyword_Return);
 
-    AstNodeTyped* expr = NULL;
+    AstTyped* expr = NULL;
 
     if (parser->curr_token->type != ';') {
         expr = parse_expression(parser);
 
-        if (expr == NULL || expr == (AstNodeTyped *) &error_node) {
-            return (AstNodeReturn *) &error_node;
+        if (expr == NULL || expr == (AstTyped *) &error_node) {
+            return (AstReturn *) &error_node;
         } else {
             return_node->expr = expr;
         }
@@ -526,7 +526,7 @@ static AstNode* parse_statement(OnyxParser* parser) {
     AstNode* retval = NULL;
 
     switch ((u16) parser->curr_token->type) {
-        case TOKEN_TYPE_KEYWORD_RETURN:
+        case Token_Type_Keyword_Return:
             retval = (AstNode *) parse_return_statement(parser);
             break;
 
@@ -535,7 +535,7 @@ static AstNode* parse_statement(OnyxParser* parser) {
             retval = (AstNode *) parse_block(parser);
             break;
 
-        case TOKEN_TYPE_SYMBOL:
+        case Token_Type_Symbol:
             if (parse_symbol_statement(parser, &retval)) break;
             // fallthrough
 
@@ -543,29 +543,29 @@ static AstNode* parse_statement(OnyxParser* parser) {
         case '+':
         case '-':
         case '!':
-        case TOKEN_TYPE_LITERAL_NUMERIC:
-        case TOKEN_TYPE_LITERAL_STRING:
+        case Token_Type_Literal_Numeric:
+        case Token_Type_Literal_String:
             retval = (AstNode *) parse_expression(parser);
             break;
 
-        case TOKEN_TYPE_KEYWORD_IF:
+        case Token_Type_Keyword_If:
             needs_semicolon = 0;
             retval = (AstNode *) parse_if_stmt(parser);
             break;
 
-        case TOKEN_TYPE_KEYWORD_WHILE:
+        case Token_Type_Keyword_While:
             needs_semicolon = 0;
             retval = (AstNode *) parse_while_stmt(parser);
             break;
 
-        case TOKEN_TYPE_KEYWORD_BREAK:
-            retval = make_node(AstNode, AST_NODE_KIND_BREAK);
-            retval->token = expect(parser, TOKEN_TYPE_KEYWORD_BREAK);
+        case Token_Type_Keyword_Break:
+            retval = make_node(AstNode, Ast_Kind_Break);
+            retval->token = expect(parser, Token_Type_Keyword_Break);
             break;
 
-        case TOKEN_TYPE_KEYWORD_CONTINUE:
-            retval = make_node(AstNode, AST_NODE_KIND_BREAK);
-            retval->token = expect(parser, TOKEN_TYPE_KEYWORD_CONTINUE);
+        case Token_Type_Keyword_Continue:
+            retval = make_node(AstNode, Ast_Kind_Break);
+            retval->token = expect(parser, Token_Type_Keyword_Continue);
             break;
 
         default:
@@ -588,9 +588,9 @@ static AstNode* parse_statement(OnyxParser* parser) {
     return retval;
 }
 
-static AstNodeBlock* parse_block(OnyxParser* parser) {
-    AstNodeBlock* block = make_node(AstNodeBlock, AST_NODE_KIND_BLOCK);
-    AstNodeLocalGroup* lg = make_node(AstNodeLocalGroup, AST_NODE_KIND_LOCAL_GROUP);
+static AstBlock* parse_block(OnyxParser* parser) {
+    AstBlock* block = make_node(AstBlock, Ast_Kind_Block);
+    AstLocalGroup* lg = make_node(AstLocalGroup, Ast_Kind_Local_Group);
     block->locals = lg;
 
     // --- is for an empty block
@@ -608,7 +608,7 @@ static AstNodeBlock* parse_block(OnyxParser* parser) {
     while (parser->curr_token->type != '}') {
         stmt = parse_statement(parser);
 
-        if (stmt != NULL && stmt->kind != AST_NODE_KIND_ERROR) {
+        if (stmt != NULL && stmt->kind != Ast_Kind_Error) {
             *next = stmt;
 
             while (stmt->next != NULL) stmt = stmt->next;
@@ -624,7 +624,7 @@ static AstNodeBlock* parse_block(OnyxParser* parser) {
 static TypeInfo* parse_type(OnyxParser* parser) {
     TypeInfo* type_info = &builtin_types[TYPE_INFO_KIND_UNKNOWN];
 
-    OnyxToken* symbol = expect(parser, TOKEN_TYPE_SYMBOL);
+    OnyxToken* symbol = expect(parser, Token_Type_Symbol);
     if (symbol == NULL) return type_info;
 
     onyx_token_null_toggle(symbol);
@@ -632,9 +632,9 @@ static TypeInfo* parse_type(OnyxParser* parser) {
     if (!bh_table_has(AstNode*, parser->identifiers, symbol->text)) {
         onyx_message_add(parser->msgs, ONYX_MESSAGE_TYPE_UNKNOWN_TYPE, symbol->pos, symbol->text);
     } else {
-        AstNodeTyped* type_info_node = bh_table_get(AstNodeTyped*, parser->identifiers, symbol->text);
+        AstTyped* type_info_node = bh_table_get(AstTyped*, parser->identifiers, symbol->text);
 
-        if (type_info_node->kind == AST_NODE_KIND_TYPE) {
+        if (type_info_node->kind == Ast_Kind_Type) {
             type_info = type_info_node->type;
         }
     }
@@ -643,7 +643,7 @@ static TypeInfo* parse_type(OnyxParser* parser) {
     return type_info;
 }
 
-static AstNodeLocal* parse_function_params(OnyxParser* parser) {
+static AstLocal* parse_function_params(OnyxParser* parser) {
     if (parser->curr_token->type != '(')
         return NULL;
 
@@ -654,20 +654,20 @@ static AstNodeLocal* parse_function_params(OnyxParser* parser) {
         return NULL;
     }
 
-    AstNodeLocal* first_param = NULL;
-    AstNodeLocal* curr_param = NULL;
-    AstNodeLocal* trailer = NULL;
+    AstLocal* first_param = NULL;
+    AstLocal* curr_param = NULL;
+    AstLocal* trailer = NULL;
 
     OnyxToken* symbol;
     while (parser->curr_token->type != ')') {
         if (parser->curr_token->type == ',') parser_next_token(parser);
 
-        symbol = expect(parser, TOKEN_TYPE_SYMBOL);
+        symbol = expect(parser, Token_Type_Symbol);
         expect(parser, ':');
 
-        curr_param = make_node(AstNodeLocal, AST_NODE_KIND_PARAM);
+        curr_param = make_node(AstLocal, Ast_Kind_Param);
         curr_param->base.token = symbol;
-        curr_param->base.flags |= ONYX_AST_FLAG_CONST;
+        curr_param->base.flags |= Ast_Flag_Const;
         curr_param->base.type = parse_type(parser);
 
         if (first_param == NULL) first_param = curr_param;
@@ -686,7 +686,7 @@ static b32 parse_possible_directive(OnyxParser* parser, const char* dir) {
     if (parser->curr_token->type != '#') return 0;
 
     expect(parser, '#');
-    OnyxToken* sym = expect(parser, TOKEN_TYPE_SYMBOL);
+    OnyxToken* sym = expect(parser, Token_Type_Symbol);
 
     b32 match = (strlen(dir) == sym->length) && (strncmp(dir, sym->text, sym->length) == 0);
     if (!match) {
@@ -696,23 +696,23 @@ static b32 parse_possible_directive(OnyxParser* parser, const char* dir) {
     return match;
 }
 
-static AstNodeFunction* parse_function_definition(OnyxParser* parser) {
-    expect(parser, TOKEN_TYPE_KEYWORD_PROC);
+static AstFunction* parse_function_definition(OnyxParser* parser) {
+    expect(parser, Token_Type_Keyword_Proc);
 
-    AstNodeFunction* func_def = make_node(AstNodeFunction, AST_NODE_KIND_FUNCTION);
+    AstFunction* func_def = make_node(AstFunction, Ast_Kind_Function);
 
     while (parser->curr_token->type == '#') {
         if (parse_possible_directive(parser, "intrinsic")) {
-            func_def->base.flags |= ONYX_AST_FLAG_INTRINSIC;
+            func_def->base.flags |= Ast_Flag_Intrinsic;
         }
 
         else if (parse_possible_directive(parser, "inline")) {
-            func_def->base.flags |= ONYX_AST_FLAG_INLINE;
+            func_def->base.flags |= Ast_Flag_Inline;
         }
 
         else {
             OnyxToken* directive_token = expect(parser, '#');
-            OnyxToken* symbol_token = expect(parser, TOKEN_TYPE_SYMBOL);
+            OnyxToken* symbol_token = expect(parser, Token_Type_Symbol);
 
             onyx_message_add(parser->msgs,
                     ONYX_MESSAGE_TYPE_UNKNOWN_DIRECTIVE,
@@ -721,11 +721,11 @@ static AstNodeFunction* parse_function_definition(OnyxParser* parser) {
         }
     }
 
-    AstNodeLocal* params = parse_function_params(parser);
+    AstLocal* params = parse_function_params(parser);
     func_def->params = params;
 
-    if (parser->curr_token->type == TOKEN_TYPE_RIGHT_ARROW) {
-        expect(parser, TOKEN_TYPE_RIGHT_ARROW);
+    if (parser->curr_token->type == Token_Type_Right_Arrow) {
+        expect(parser, Token_Type_Right_Arrow);
 
         TypeInfo* return_type = parse_type(parser);
         func_def->base.type = return_type;
@@ -739,21 +739,21 @@ static AstNodeFunction* parse_function_definition(OnyxParser* parser) {
 }
 
 static AstNode* parse_foreign(OnyxParser* parser) {
-    expect(parser, TOKEN_TYPE_KEYWORD_FOREIGN);
+    expect(parser, Token_Type_Keyword_Foreign);
 
-    AstNodeForeign* foreign = make_node(AstNodeForeign, AST_NODE_KIND_FOREIGN);
-    foreign->mod_token = expect(parser, TOKEN_TYPE_LITERAL_STRING);
-    foreign->name_token = expect(parser, TOKEN_TYPE_LITERAL_STRING);
+    AstForeign* foreign = make_node(AstForeign, Ast_Kind_Foreign);
+    foreign->mod_token = expect(parser, Token_Type_Literal_String);
+    foreign->name_token = expect(parser, Token_Type_Literal_String);
 
-    if (parser->curr_token->type == TOKEN_TYPE_KEYWORD_PROC) {
+    if (parser->curr_token->type == Token_Type_Keyword_Proc) {
         foreign->import = (AstNode *) parse_function_definition(parser);
 
     } else {
         TypeInfo* type = parse_type(parser);
 
-        AstNodeGlobal* global = make_node(AstNodeGlobal, AST_NODE_KIND_GLOBAL);
+        AstGlobal* global = make_node(AstGlobal, Ast_Kind_Global);
         global->base.type = type;
-        global->base.flags |= ONYX_AST_FLAG_LVAL;
+        global->base.flags |= Ast_Flag_Lval;
 
         foreign->import = (AstNode *) global;
     }
@@ -762,24 +762,24 @@ static AstNode* parse_foreign(OnyxParser* parser) {
 }
 
 static AstNode* parse_top_level_constant_symbol(OnyxParser* parser) {
-    if (parser->curr_token->type == TOKEN_TYPE_KEYWORD_PROC) {
+    if (parser->curr_token->type == Token_Type_Keyword_Proc) {
         return (AstNode *) parse_function_definition(parser);
 
-    } else if (parser->curr_token->type == TOKEN_TYPE_KEYWORD_STRUCT) {
+    } else if (parser->curr_token->type == Token_Type_Keyword_Struct) {
         // Handle struct case
         assert(0);
 
-    } else if (parser->curr_token->type == TOKEN_TYPE_KEYWORD_FOREIGN) {
+    } else if (parser->curr_token->type == Token_Type_Keyword_Foreign) {
         return (AstNode *) parse_foreign(parser);
 
     } else {
         // Global constant with initial value
-        AstNodeGlobal* global = make_node(AstNodeGlobal, AST_NODE_KIND_GLOBAL);
+        AstGlobal* global = make_node(AstGlobal, Ast_Kind_Global);
         global->initial_value = parse_expression(parser);
         global->base.type = &builtin_types[TYPE_INFO_KIND_UNKNOWN];
-        global->base.flags |= ONYX_AST_FLAG_CONST;
-        global->base.flags |= ONYX_AST_FLAG_LVAL;
-        global->base.flags |= ONYX_AST_FLAG_COMPTIME;
+        global->base.flags |= Ast_Flag_Const;
+        global->base.flags |= Ast_Flag_Lval;
+        global->base.flags |= Ast_Flag_Comptime;
 
         return (AstNode *) global;
     }
@@ -787,33 +787,33 @@ static AstNode* parse_top_level_constant_symbol(OnyxParser* parser) {
 
 static AstNode* parse_top_level_statement(OnyxParser* parser) {
     switch (parser->curr_token->type) {
-        case TOKEN_TYPE_KEYWORD_USE:
+        case Token_Type_Keyword_Use:
             {
-                AstNodeUse* use_node = make_node(AstNodeUse, AST_NODE_KIND_USE);
-                use_node->base.token = expect(parser, TOKEN_TYPE_KEYWORD_USE);
-                use_node->filename = expect(parser, TOKEN_TYPE_LITERAL_STRING);
+                AstUse* use_node = make_node(AstUse, Ast_Kind_Use);
+                use_node->base.token = expect(parser, Token_Type_Keyword_Use);
+                use_node->filename = expect(parser, Token_Type_Literal_String);
 
                 return (AstNode *) use_node;
             }
 
-        case TOKEN_TYPE_KEYWORD_EXPORT:
+        case Token_Type_Keyword_Export:
             {
-                expect(parser, TOKEN_TYPE_KEYWORD_EXPORT);
-                if (parser->curr_token->type != TOKEN_TYPE_SYMBOL) {
+                expect(parser, Token_Type_Keyword_Export);
+                if (parser->curr_token->type != Token_Type_Symbol) {
                     onyx_message_add(parser->msgs,
                             ONYX_MESSAGE_TYPE_EXPECTED_TOKEN,
                             parser->curr_token->pos,
-                            onyx_get_token_type_name(TOKEN_TYPE_SYMBOL),
+                            onyx_get_token_type_name(Token_Type_Symbol),
                             onyx_get_token_type_name(parser->curr_token->type));
                     break;
                 }
 
                 AstNode* top_level_decl = parse_top_level_statement(parser);
-                top_level_decl->flags |= ONYX_AST_FLAG_EXPORTED;
+                top_level_decl->flags |= Ast_Flag_Exported;
                 return top_level_decl;
             }
 
-        case TOKEN_TYPE_SYMBOL:
+        case Token_Type_Symbol:
             {
                 OnyxToken* symbol = parser->curr_token;
                 parser_next_token(parser);
@@ -822,7 +822,7 @@ static AstNode* parse_top_level_statement(OnyxParser* parser) {
 
                 TypeInfo* type = &builtin_types[TYPE_INFO_KIND_UNKNOWN];
 
-                if (parser->curr_token->type == TOKEN_TYPE_SYMBOL) {
+                if (parser->curr_token->type == Token_Type_Symbol) {
                     type = parse_type(parser);
                 }
 
@@ -831,12 +831,12 @@ static AstNode* parse_top_level_statement(OnyxParser* parser) {
 
                     AstNode* node = parse_top_level_constant_symbol(parser);
 
-                    if (node->kind == AST_NODE_KIND_GLOBAL) {
-                        ((AstNodeGlobal *) node)->base.type = type;
+                    if (node->kind == Ast_Kind_Global) {
+                        ((AstGlobal *) node)->base.type = type;
                     }
 
-                    if (node->kind == AST_NODE_KIND_FOREIGN) {
-                        ((AstNodeForeign *) node)->import->token = symbol;
+                    if (node->kind == Ast_Kind_Foreign) {
+                        ((AstForeign *) node)->import->token = symbol;
 
                     } else {
                         node->token = symbol;
@@ -847,9 +847,9 @@ static AstNode* parse_top_level_statement(OnyxParser* parser) {
                 } else if (parser->curr_token->type == '=') {
                     parser_next_token(parser);
 
-                    AstNodeGlobal* global = make_node(AstNodeGlobal, AST_NODE_KIND_GLOBAL);
+                    AstGlobal* global = make_node(AstGlobal, Ast_Kind_Global);
                     global->base.token = symbol;
-                    global->base.flags |= ONYX_AST_FLAG_LVAL;
+                    global->base.flags |= Ast_Flag_Lval;
                     global->initial_value = parse_expression(parser);
                     global->base.type = type;
 
@@ -879,11 +879,11 @@ static AstNode* parse_top_level_statement(OnyxParser* parser) {
 
 
 // NOTE: This returns a void* so I don't need to cast it everytime I use it
-void* onyx_ast_node_new(bh_allocator alloc, i32 size, AstNodeKind kind) {
+void* onyx_ast_node_new(bh_allocator alloc, i32 size, AstKind kind) {
     void* node = bh_alloc(alloc, size);
 
     memset(node, 0, size);
-    *(AstNodeKind *) node = kind;
+    *(AstKind *) node = kind;
 
     return node;
 }
@@ -895,7 +895,7 @@ OnyxParser onyx_parser_create(bh_allocator alloc, OnyxTokenizer *tokenizer, Onyx
 
     TypeInfo* it = &builtin_types[0];
     while (it->kind != 0xffffffff) {
-        AstNodeTyped* tmp = onyx_ast_node_new(alloc, sizeof(AstNodeTyped), AST_NODE_KIND_TYPE);
+        AstTyped* tmp = onyx_ast_node_new(alloc, sizeof(AstTyped), Ast_Kind_Type);
         tmp->type = it;
         bh_table_put(AstNode*, parser.identifiers, (char *)it->name, tmp);
         it++;
@@ -916,7 +916,7 @@ bh_arr(AstNode *) onyx_parse(OnyxParser *parser) {
     bh_arr(AstNode *) top_level_nodes = NULL;
     bh_arr_new(global_heap_allocator, top_level_nodes, 4);
 
-    while (parser->curr_token->type != TOKEN_TYPE_END_STREAM) {
+    while (parser->curr_token->type != Token_Type_End_Stream) {
         AstNode* curr_stmt = parse_top_level_statement(parser);
 
         // Building a linked list of statements down the "next" chain
diff --git a/src/onyxsempass.c b/src/onyxsempass.c
index df81f551..7f2b4bc8 100644
--- a/src/onyxsempass.c
+++ b/src/onyxsempass.c
@@ -24,19 +24,19 @@ OnyxSemPassState onyx_sempass_create(bh_allocator alloc, bh_allocator node_alloc
 // defined in sub-scopes up to the function-block level. This is a
 // requirement of WASM, but not of other targets.
 static void collapse_scopes(OnyxProgram* program) {
-    bh_arr(AstNodeBlock*) traversal_queue = NULL;
+    bh_arr(AstBlock*) traversal_queue = NULL;
     bh_arr_new(global_scratch_allocator, traversal_queue, 4);
     bh_arr_set_length(traversal_queue, 0);
 
-    bh_arr_each(AstNodeFunction *, func, program->functions) {
-        AstNodeLocalGroup* top_locals = (*func)->body->locals;
+    bh_arr_each(AstFunction *, func, program->functions) {
+        AstLocalGroup* top_locals = (*func)->body->locals;
 
         bh_arr_push(traversal_queue, (*func)->body);
         while (!bh_arr_is_empty(traversal_queue)) {
-            AstNodeBlock* block = traversal_queue[0];
+            AstBlock* block = traversal_queue[0];
 
-            if (block->base.kind == AST_NODE_KIND_IF) {
-                AstNodeIf* if_node = (AstNodeIf *) block;
+            if (block->base.kind == Ast_Kind_If) {
+                AstIf* if_node = (AstIf *) block;
                 if (if_node->true_block.as_block != NULL)
                     bh_arr_push(traversal_queue, if_node->true_block.as_block);
 
@@ -46,7 +46,7 @@ static void collapse_scopes(OnyxProgram* program) {
             } else {
 
                 if (block->locals != top_locals && block->locals->last_local != NULL) {
-                    AstNodeLocal* last_local = block->locals->last_local;
+                    AstLocal* last_local = block->locals->last_local;
                     while (last_local && last_local->prev_local != NULL) last_local = last_local->prev_local;
 
                     last_local->prev_local = top_locals->last_local;
@@ -56,18 +56,18 @@ static void collapse_scopes(OnyxProgram* program) {
 
                 AstNode* walker = block->body;
                 while (walker) {
-                    if (walker->kind == AST_NODE_KIND_BLOCK) {
-                        bh_arr_push(traversal_queue, (AstNodeBlock *) walker);
+                    if (walker->kind == Ast_Kind_Block) {
+                        bh_arr_push(traversal_queue, (AstBlock *) walker);
 
-                    } else if (walker->kind == AST_NODE_KIND_WHILE) {
-                        bh_arr_push(traversal_queue, ((AstNodeWhile *) walker)->body);
+                    } else if (walker->kind == Ast_Kind_While) {
+                        bh_arr_push(traversal_queue, ((AstWhile *) walker)->body);
 
-                    } else if (walker->kind == AST_NODE_KIND_IF) {
-                        if (((AstNodeIf *) walker)->true_block.as_block != NULL)
-                            bh_arr_push(traversal_queue, ((AstNodeIf *) walker)->true_block.as_block);
+                    } else if (walker->kind == Ast_Kind_If) {
+                        if (((AstIf *) walker)->true_block.as_block != NULL)
+                            bh_arr_push(traversal_queue, ((AstIf *) walker)->true_block.as_block);
 
-                        if (((AstNodeIf *) walker)->false_block.as_block != NULL)
-                            bh_arr_push(traversal_queue, ((AstNodeIf *) walker)->false_block.as_block);
+                        if (((AstIf *) walker)->false_block.as_block != NULL)
+                            bh_arr_push(traversal_queue, ((AstIf *) walker)->false_block.as_block);
                     }
 
                     walker = walker->next;
diff --git a/src/onyxsymres.c b/src/onyxsymres.c
index accec6e5..e3a19b5d 100644
--- a/src/onyxsymres.c
+++ b/src/onyxsymres.c
@@ -5,19 +5,19 @@ static void symbol_introduce(OnyxSemPassState* state, AstNode* symbol);
 static b32 symbol_unique_introduce(OnyxSemPassState* state, AstNode* symbol);
 static void symbol_remove(OnyxSemPassState* state, AstNode* symbol);
 static AstNode* symbol_resolve(OnyxSemPassState* state, AstNode* symbol);
-static void local_group_enter(OnyxSemPassState* state, AstNodeLocalGroup* local_group);
+static void local_group_enter(OnyxSemPassState* state, AstLocalGroup* local_group);
 static void local_group_leave(OnyxSemPassState* state);
-static void symres_local(OnyxSemPassState* state, AstNodeLocal** local);
-static void symres_call(OnyxSemPassState* state, AstNodeCall* call);
+static void symres_local(OnyxSemPassState* state, AstLocal** local);
+static void symres_call(OnyxSemPassState* state, AstCall* call);
 static void symres_expression(OnyxSemPassState* state, AstNode** expr);
-static void symres_assignment(OnyxSemPassState* state, AstNodeAssign* assign);
-static void symres_return(OnyxSemPassState* state, AstNodeReturn* ret);
-static void symres_if(OnyxSemPassState* state, AstNodeIf* ifnode);
-static void symres_while(OnyxSemPassState* state, AstNodeWhile* whilenode);
+static void symres_assignment(OnyxSemPassState* state, AstAssign* assign);
+static void symres_return(OnyxSemPassState* state, AstReturn* ret);
+static void symres_if(OnyxSemPassState* state, AstIf* ifnode);
+static void symres_while(OnyxSemPassState* state, AstWhile* whilenode);
 static void symres_statement_chain(OnyxSemPassState* state, AstNode* walker, AstNode** trailer);
 static b32 symres_statement(OnyxSemPassState* state, AstNode* stmt);
-static void symres_block(OnyxSemPassState* state, AstNodeBlock* block);
-static void symres_function(OnyxSemPassState* state, AstNodeFunction* func);
+static void symres_block(OnyxSemPassState* state, AstBlock* block);
+static void symres_function(OnyxSemPassState* state, AstFunction* func);
 
 static void symbol_introduce(OnyxSemPassState* state, AstNode* symbol) {
     onyx_token_null_toggle(symbol->token);
@@ -32,8 +32,8 @@ static void symbol_introduce(OnyxSemPassState* state, AstNode* symbol) {
 
     bh_table_put(SemPassSymbol *, state->symbols, symbol->token->text, sp_sym);
 
-    if (symbol->kind == AST_NODE_KIND_LOCAL) {
-        AstNodeLocal* local = (AstNodeLocal *) symbol;
+    if (symbol->kind == Ast_Kind_Local) {
+        AstLocal* local = (AstLocal *) symbol;
         local->prev_local = state->curr_local_group->last_local;
         state->curr_local_group->last_local = local;
     }
@@ -74,7 +74,7 @@ static AstNode* symbol_resolve(OnyxSemPassState* state, AstNode* symbol) {
     return sp_sym->node;
 }
 
-static void local_group_enter(OnyxSemPassState* state, AstNodeLocalGroup* local_group) {
+static void local_group_enter(OnyxSemPassState* state, AstLocalGroup* local_group) {
     local_group->prev_group = state->curr_local_group;
     state->curr_local_group = local_group;
 }
@@ -82,7 +82,7 @@ static void local_group_enter(OnyxSemPassState* state, AstNodeLocalGroup* local_
 static void local_group_leave(OnyxSemPassState* state) {
     assert(state->curr_local_group != NULL);
 
-    for (AstNodeLocal *walker = state->curr_local_group->last_local; walker != NULL; walker = walker->prev_local) {
+    for (AstLocal *walker = state->curr_local_group->last_local; walker != NULL; walker = walker->prev_local) {
         symbol_remove(state, (AstNode *) walker);
     }
 
@@ -113,11 +113,11 @@ static b32 symbol_unique_introduce(OnyxSemPassState* state, AstNode* symbol) {
     return 1;
 }
 
-static void symres_local(OnyxSemPassState* state, AstNodeLocal** local) {
+static void symres_local(OnyxSemPassState* state, AstLocal** local) {
     symbol_introduce(state, (AstNode *) *local);
 }
 
-static void symres_call(OnyxSemPassState* state, AstNodeCall* call) {
+static void symres_call(OnyxSemPassState* state, AstCall* call) {
     AstNode* callee = symbol_resolve(state, call->callee);
     if (callee) call->callee = callee;
     else DEBUG_HERE;
@@ -127,27 +127,27 @@ static void symres_call(OnyxSemPassState* state, AstNodeCall* call) {
 
 static void symres_expression(OnyxSemPassState* state, AstNode** expr) {
     switch ((*expr)->kind) {
-        case AST_NODE_KIND_BIN_OP:
-            symres_expression(state, (AstNode **) &((AstNodeBinOp *)(*expr))->left);
-            symres_expression(state, (AstNode **) &((AstNodeBinOp *)(*expr))->right);
+        case Ast_Kind_Binary_Op:
+            symres_expression(state, (AstNode **) &((AstBinaryOp *)(*expr))->left);
+            symres_expression(state, (AstNode **) &((AstBinaryOp *)(*expr))->right);
             break;
 
-        case AST_NODE_KIND_UNARY_OP:
-            symres_expression(state, (AstNode **) &((AstNodeUnaryOp *)(*expr))->expr);
+        case Ast_Kind_Unary_Op:
+            symres_expression(state, (AstNode **) &((AstUnaryOp *)(*expr))->expr);
             break;
 
-        case AST_NODE_KIND_CALL: symres_call(state, (AstNodeCall *) *expr); break;
+        case Ast_Kind_Call: symres_call(state, (AstCall *) *expr); break;
 
-        case AST_NODE_KIND_BLOCK: symres_block(state, (AstNodeBlock *) *expr); break;
+        case Ast_Kind_Block: symres_block(state, (AstBlock *) *expr); break;
 
-        case AST_NODE_KIND_SYMBOL:
+        case Ast_Kind_Symbol:
             *expr = symbol_resolve(state, *expr);
             break;
 
         // NOTE: This is a good case, since it means the symbol is already resolved
-        case AST_NODE_KIND_LOCAL: break;
+        case Ast_Kind_Local: break;
 
-        case AST_NODE_KIND_LITERAL: break;
+        case Ast_Kind_Literal: break;
 
         default:
             DEBUG_HERE;
@@ -155,43 +155,43 @@ static void symres_expression(OnyxSemPassState* state, AstNode** expr) {
     }
 }
 
-static void symres_assignment(OnyxSemPassState* state, AstNodeAssign* assign) {
-    AstNodeTyped* lval = (AstNodeTyped *) symbol_resolve(state, (AstNode *) assign->lval);
+static void symres_assignment(OnyxSemPassState* state, AstAssign* assign) {
+    AstTyped* lval = (AstTyped *) symbol_resolve(state, (AstNode *) assign->lval);
     if (lval == NULL) return;
     assign->lval = lval;
 
     symres_expression(state, (AstNode **) &assign->expr);
 }
 
-static void symres_return(OnyxSemPassState* state, AstNodeReturn* ret) {
+static void symres_return(OnyxSemPassState* state, AstReturn* ret) {
     if (ret->expr)
         symres_expression(state, (AstNode **) &ret->expr);
 }
 
-static void symres_if(OnyxSemPassState* state, AstNodeIf* ifnode) {
+static void symres_if(OnyxSemPassState* state, AstIf* ifnode) {
     symres_expression(state, (AstNode **) &ifnode->cond);
     if (ifnode->true_block.as_if != NULL) {
-        if (ifnode->true_block.as_if->base.kind == AST_NODE_KIND_BLOCK)
+        if (ifnode->true_block.as_if->base.kind == Ast_Kind_Block)
             symres_block(state, ifnode->true_block.as_block);
 
-        else if (ifnode->true_block.as_if->base.kind == AST_NODE_KIND_IF)
+        else if (ifnode->true_block.as_if->base.kind == Ast_Kind_If)
             symres_if(state, ifnode->true_block.as_if);
 
         else DEBUG_HERE;
     }
 
     if (ifnode->false_block.as_if != NULL) {
-        if (ifnode->false_block.as_if->base.kind == AST_NODE_KIND_BLOCK)
+        if (ifnode->false_block.as_if->base.kind == Ast_Kind_Block)
             symres_block(state, ifnode->false_block.as_block);
 
-        else if (ifnode->false_block.as_if->base.kind == AST_NODE_KIND_IF)
+        else if (ifnode->false_block.as_if->base.kind == Ast_Kind_If)
             symres_if(state, ifnode->false_block.as_if);
 
         else DEBUG_HERE;
     }
 }
 
-static void symres_while(OnyxSemPassState* state, AstNodeWhile* whilenode) {
+static void symres_while(OnyxSemPassState* state, AstWhile* whilenode) {
     symres_expression(state, (AstNode **) &whilenode->cond);
     symres_block(state, whilenode->body);
 }
@@ -199,14 +199,14 @@ static void symres_while(OnyxSemPassState* state, AstNodeWhile* whilenode) {
 // NOTE: Returns 1 if the statment should be removed
 static b32 symres_statement(OnyxSemPassState* state, AstNode* stmt) {
     switch (stmt->kind) {
-        case AST_NODE_KIND_LOCAL:      symres_local(state, (AstNodeLocal **) &stmt);                return 1;
-        case AST_NODE_KIND_ASSIGNMENT: symres_assignment(state, (AstNodeAssign *) stmt);            return 0;
-        case AST_NODE_KIND_RETURN:     symres_return(state, (AstNodeReturn *) stmt);                return 0;
-        case AST_NODE_KIND_IF:         symres_if(state, (AstNodeIf *) stmt);                        return 0;
-        case AST_NODE_KIND_WHILE:      symres_while(state, (AstNodeWhile *) stmt);                 return 0;
-        case AST_NODE_KIND_CALL:       symres_call(state, (AstNodeCall *) stmt);                    return 0;
-        case AST_NODE_KIND_ARGUMENT:   symres_expression(state, (AstNode **) &((AstNodeArgument *)stmt)->value); return 0;
-        case AST_NODE_KIND_BLOCK:      symres_block(state, (AstNodeBlock *) stmt);                  return 0;
+        case Ast_Kind_Local:      symres_local(state, (AstLocal **) &stmt);                return 1;
+        case Ast_Kind_Assignment: symres_assignment(state, (AstAssign *) stmt);            return 0;
+        case Ast_Kind_Return:     symres_return(state, (AstReturn *) stmt);                return 0;
+        case Ast_Kind_If:         symres_if(state, (AstIf *) stmt);                        return 0;
+        case Ast_Kind_While:      symres_while(state, (AstWhile *) stmt);                 return 0;
+        case Ast_Kind_Call:       symres_call(state, (AstCall *) stmt);                    return 0;
+        case Ast_Kind_Argument:   symres_expression(state, (AstNode **) &((AstArgument *)stmt)->value); return 0;
+        case Ast_Kind_Block:      symres_block(state, (AstBlock *) stmt);                  return 0;
 
         default: return 0;
     }
@@ -227,21 +227,21 @@ static void symres_statement_chain(OnyxSemPassState* state, AstNode* walker, Ast
     }
 }
 
-static void symres_block(OnyxSemPassState* state, AstNodeBlock* block) {
+static void symres_block(OnyxSemPassState* state, AstBlock* block) {
     local_group_enter(state, block->locals);
     if (block->body)
         symres_statement_chain(state, block->body, &block->body);
     local_group_leave(state);
 }
 
-static void symres_function(OnyxSemPassState* state, AstNodeFunction* func) {
-    for (AstNodeLocal *param = func->params; param != NULL; param = (AstNodeLocal *) param->base.next) {
+static void symres_function(OnyxSemPassState* state, AstFunction* func) {
+    for (AstLocal *param = func->params; param != NULL; param = (AstLocal *) param->base.next) {
         symbol_introduce(state, (AstNode *) param);
     }
 
     symres_block(state, func->body);
 
-    for (AstNodeLocal *param = func->params; param != NULL; param = (AstNodeLocal *) param->base.next) {
+    for (AstLocal *param = func->params; param != NULL; param = (AstLocal *) param->base.next) {
         symbol_remove(state, (AstNode *) param);
     }
 }
@@ -249,21 +249,21 @@ static void symres_function(OnyxSemPassState* state, AstNodeFunction* func) {
 void onyx_resolve_symbols(OnyxSemPassState* state, OnyxProgram* program) {
 
     // NOTE: First, introduce all global symbols
-    bh_arr_each(AstNodeGlobal *, global, program->globals)
+    bh_arr_each(AstGlobal *, global, program->globals)
         if (!symbol_unique_introduce(state, (AstNode *) *global)) return;
 
-    bh_arr_each(AstNodeFunction *, function, program->functions)
+    bh_arr_each(AstFunction *, function, program->functions)
         if (!symbol_unique_introduce(state, (AstNode *) *function)) return;
 
-    bh_arr_each(AstNodeForeign *, foreign, program->foreigns) {
-        AstNodeKind import_kind = (*foreign)->import->kind;
+    bh_arr_each(AstForeign *, foreign, program->foreigns) {
+        AstKind import_kind = (*foreign)->import->kind;
 
-        if (import_kind == AST_NODE_KIND_FUNCTION || import_kind == AST_NODE_KIND_GLOBAL)
+        if (import_kind == Ast_Kind_Function || import_kind == Ast_Kind_Global)
             if (!symbol_unique_introduce(state, (*foreign)->import)) return;
     }
 
 
     // NOTE: Then, resolve all symbols in all functions
-    bh_arr_each(AstNodeFunction *, function, program->functions)
+    bh_arr_each(AstFunction *, function, program->functions)
         symres_function(state, *function);
 }
diff --git a/src/onyxtypes.c b/src/onyxtypes.c
new file mode 100644
index 00000000..eee00a7d
--- /dev/null
+++ b/src/onyxtypes.c
@@ -0,0 +1,49 @@
+#include "onyxtypes.h"
+
+Type basic_types[] = {
+    { Type_Kind_Basic, { Basic_Kind_Void,                    0,                       0, "void"   } },
+
+    { Type_Kind_Basic, { Basic_Kind_Bool,   Basic_Flag_Boolean,                       1, "bool"   } },
+
+    { Type_Kind_Basic, { Basic_Kind_I8,     Basic_Flag_Integer,                       1, "i8"     } },
+    { Type_Kind_Basic, { Basic_Kind_I16,    Basic_Flag_Integer,                       2, "i16"    } },
+    { Type_Kind_Basic, { Basic_Kind_I32,    Basic_Flag_Integer,                       4, "i32"    } },
+    { Type_Kind_Basic, { Basic_Kind_I64,    Basic_Flag_Integer,                       8, "i64"    } },
+
+    { Type_Kind_Basic, { Basic_Kind_U8,     Basic_Flag_Integer | Basic_Flag_Unsigned, 1, "u8"     } },
+    { Type_Kind_Basic, { Basic_Kind_U16,    Basic_Flag_Integer | Basic_Flag_Unsigned, 2, "u16"    } },
+    { Type_Kind_Basic, { Basic_Kind_U32,    Basic_Flag_Integer | Basic_Flag_Unsigned, 4, "u32"    } },
+    { Type_Kind_Basic, { Basic_Kind_U64,    Basic_Flag_Integer | Basic_Flag_Unsigned, 8, "u64"    } },
+
+    { Type_Kind_Basic, { Basic_Kind_F32,    Basic_Flag_Float,                         4, "f32"    } },
+    { Type_Kind_Basic, { Basic_Kind_F64,    Basic_Flag_Float,                         8, "f64"    } },
+
+    { Type_Kind_Basic, { Basic_Kind_Rawptr, Basic_Flag_Pointer,                       4, "rawptr" } },
+};
+
+b32 types_are_compatible(Type* t1, Type* t2) {
+    // NOTE: If they are pointing to the same thing,
+    // it is safe to assume they are the same type
+    if (t1 == t2) return 1;
+
+    switch (t1->kind) {
+        case Type_Kind_Basic:
+            if (t2->kind == Type_Kind_Basic) {
+                // HACK: Not sure if this is right way to check this?
+                return t1 == t2;
+            }
+            break;
+
+        case Type_Kind_Pointer:
+            if (t2->kind == Type_Kind_Pointer) {
+                return types_are_compatible(t1->Pointer.elem, t2->Pointer.elem);
+            }
+            break;
+
+        default:
+            assert(("Invalid type", 0));
+            break;
+    }
+
+    return 0;
+}
diff --git a/src/onyxutils.c b/src/onyxutils.c
index 3e55d696..b98f5dd8 100644
--- a/src/onyxutils.c
+++ b/src/onyxutils.c
@@ -41,7 +41,7 @@ static const char* ast_node_names[] = {
     "AST_NODE_KIND_COUNT",
 };
 
-const char* onyx_ast_node_kind_string(AstNodeKind kind) {
+const char* onyx_ast_node_kind_string(AstKind kind) {
     return ast_node_names[kind];
 }
 
diff --git a/src/onyxwasm.c b/src/onyxwasm.c
index 3b4de695..aaee1bbb 100644
--- a/src/onyxwasm.c
+++ b/src/onyxwasm.c
@@ -212,22 +212,22 @@ static WasmType onyx_type_to_wasm_type(TypeInfo* type) {
 #define WI(instr) bh_arr_push(code, ((WasmInstruction){ instr, 0x00 }));
 #define WID(instr, data) bh_arr_push(code, ((WasmInstruction){ instr, data }));
 
-static void compile_function_body(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeFunction* fd);
-static void compile_block(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeBlock* block);
+static void compile_function_body(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstFunction* fd);
+static void compile_block(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstBlock* block);
 static void compile_statement(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNode* stmt);
-static void compile_assign_lval(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeTyped* lval);
-static void compile_assignment(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeAssign* assign);
-static void compile_if(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeIf* if_node);
-static void compile_while(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeWhile* while_node);
-static void compile_binop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeBinOp* binop);
-static void compile_unaryop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeUnaryOp* unop);
-static void compile_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeCall* call);
-static void compile_intrinsic_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeIntrinsicCall* call);
-static void compile_expression(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeTyped* expr);
-static void compile_cast(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeUnaryOp* cast);
-static void compile_return(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeReturn* ret);
-
-static void compile_function_body(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeFunction* fd) {
+static void compile_assign_lval(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstTyped* lval);
+static void compile_assignment(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstAssign* assign);
+static void compile_if(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstIf* if_node);
+static void compile_while(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstWhile* while_node);
+static void compile_binop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstBinaryOp* binop);
+static void compile_unaryop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstUnaryOp* unop);
+static void compile_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstCall* call);
+static void compile_intrinsic_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstIntrinsicCall* call);
+static void compile_expression(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstTyped* expr);
+static void compile_cast(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstUnaryOp* cast);
+static void compile_return(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstReturn* ret);
+
+static void compile_function_body(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstFunction* fd) {
     if (fd->body == NULL) return;
 
     bh_arr(WasmInstruction) code = *pcode;
@@ -241,7 +241,7 @@ static void compile_function_body(OnyxWasmModule* mod, bh_arr(WasmInstruction)*
     *pcode = code;
 }
 
-static void compile_block(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeBlock* block) {
+static void compile_block(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstBlock* block) {
     bh_arr(WasmInstruction) code = *pcode;
 
     WID(WI_BLOCK_START, 0x40);
@@ -285,17 +285,17 @@ static void compile_statement(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcod
     bh_arr(WasmInstruction) code = *pcode;
 
     switch (stmt->kind) {
-        case AST_NODE_KIND_RETURN: compile_return(mod, &code, (AstNodeReturn *) stmt); break;
-        case AST_NODE_KIND_ASSIGNMENT: compile_assignment(mod, &code, (AstNodeAssign *) stmt); break;
-        case AST_NODE_KIND_IF: compile_if(mod, &code, (AstNodeIf *) stmt); break;
-        case AST_NODE_KIND_WHILE: compile_while(mod, &code, (AstNodeWhile *) stmt); break;
-        case AST_NODE_KIND_BREAK: compile_structured_jump(mod, &code, 0); break;
-        case AST_NODE_KIND_CONTINUE: compile_structured_jump(mod, &code, 1); break;
-        case AST_NODE_KIND_BLOCK: compile_block(mod, &code, (AstNodeBlock *) stmt); break;
-
-        case AST_NODE_KIND_CALL:
-        case AST_NODE_KIND_INTRINSIC_CALL:
-            compile_expression(mod, &code, (AstNodeTyped *) stmt);
+        case Ast_Kind_Return: compile_return(mod, &code, (AstReturn *) stmt); break;
+        case Ast_Kind_Assignment: compile_assignment(mod, &code, (AstAssign *) stmt); break;
+        case Ast_Kind_If: compile_if(mod, &code, (AstIf *) stmt); break;
+        case Ast_Kind_While: compile_while(mod, &code, (AstWhile *) stmt); break;
+        case Ast_Kind_Break: compile_structured_jump(mod, &code, 0); break;
+        case Ast_Kind_Continue: compile_structured_jump(mod, &code, 1); break;
+        case Ast_Kind_Block: compile_block(mod, &code, (AstBlock *) stmt); break;
+
+        case Ast_Kind_Call:
+        case Ast_Kind_Intrinsic_Call:
+            compile_expression(mod, &code, (AstTyped *) stmt);
             break;
 
 
@@ -305,15 +305,15 @@ static void compile_statement(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcod
     *pcode = code;
 }
 
-static void compile_assign_lval(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeTyped* lval) {
+static void compile_assign_lval(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstTyped* lval) {
     bh_arr(WasmInstruction) code = *pcode;
 
-    if (lval->kind == AST_NODE_KIND_LOCAL || lval->kind == AST_NODE_KIND_PARAM) {
+    if (lval->kind == Ast_Kind_Local || lval->kind == Ast_Kind_Param) {
         i32 localidx = (i32) bh_imap_get(&mod->local_map, (u64) lval);
 
         WID(WI_LOCAL_SET, localidx);
 
-    } else if (lval->kind == AST_NODE_KIND_GLOBAL) {
+    } else if (lval->kind == Ast_Kind_Global) {
         i32 globalidx = (i32) bh_imap_get(&mod->global_map, (u64) lval);
 
         WID(WI_GLOBAL_SET, globalidx);
@@ -325,7 +325,7 @@ static void compile_assign_lval(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pc
     *pcode = code;
 }
 
-static void compile_if(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeIf* if_node) {
+static void compile_if(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstIf* if_node) {
     bh_arr(WasmInstruction) code = *pcode;
 
     compile_expression(mod, &code, if_node->cond);
@@ -336,11 +336,11 @@ static void compile_if(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstN
     if (if_node->true_block.as_if) {
         // NOTE: This is kind of gross, but making a function for this doesn't feel right
 
-        if (if_node->true_block.as_if->base.kind == AST_NODE_KIND_IF) {
+        if (if_node->true_block.as_if->base.kind == Ast_Kind_If) {
             forll (AstNode, stmt, (AstNode *) if_node->true_block.as_if, next) {
                 compile_statement(mod, &code, stmt);
             }
-        } else if (if_node->true_block.as_if->base.kind == AST_NODE_KIND_BLOCK) {
+        } else if (if_node->true_block.as_if->base.kind == Ast_Kind_Block) {
             forll (AstNode, stmt, if_node->true_block.as_block->body, next) {
                 compile_statement(mod, &code, stmt);
             }
@@ -350,11 +350,11 @@ static void compile_if(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstN
     if (if_node->false_block.as_if) {
         WI(WI_ELSE);
 
-        if (if_node->false_block.as_if->base.kind == AST_NODE_KIND_IF) {
+        if (if_node->false_block.as_if->base.kind == Ast_Kind_If) {
             forll (AstNode, stmt, (AstNode *) if_node->false_block.as_if, next) {
                 compile_statement(mod, &code, stmt);
             }
-        } else if (if_node->false_block.as_if->base.kind == AST_NODE_KIND_BLOCK) {
+        } else if (if_node->false_block.as_if->base.kind == Ast_Kind_Block) {
             forll (AstNode, stmt, if_node->false_block.as_block->body, next) {
                 compile_statement(mod, &code, stmt);
             }
@@ -368,7 +368,7 @@ static void compile_if(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstN
     *pcode = code;
 }
 
-static void compile_while(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeWhile* while_node) {
+static void compile_while(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstWhile* while_node) {
     bh_arr(WasmInstruction) code = *pcode;
 
     WID(WI_BLOCK_START, 0x40);
@@ -396,7 +396,7 @@ static void compile_while(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, A
     *pcode = code;
 }
 
-static void compile_assignment(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeAssign* assign) {
+static void compile_assignment(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstAssign* assign) {
     bh_arr(WasmInstruction) code = *pcode;
 
     compile_expression(mod, &code, assign->expr);
@@ -423,18 +423,18 @@ static const WasmInstructionType binop_map[][4] = {
     /* GTE */ { WI_I32_GE_S,  WI_I64_GE_S,  WI_F32_GE,  WI_F64_GE },
 };
 
-static void compile_binop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeBinOp* binop) {
+static void compile_binop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstBinaryOp* binop) {
     bh_arr(WasmInstruction) code = *pcode;
 
     b32 is_sign_significant = 0;
 
     switch (binop->operation) {
-        case ONYX_BINARY_OP_DIVIDE:
-        case ONYX_BINARY_OP_MODULUS:
-        case ONYX_BINARY_OP_LESS:
-        case ONYX_BINARY_OP_LESS_EQUAL:
-        case ONYX_BINARY_OP_GREATER:
-        case ONYX_BINARY_OP_GREATER_EQUAL:
+        case Binary_Op_Divide:
+        case Binary_Op_Modulus:
+        case Binary_Op_Less:
+        case Binary_Op_Less_Equal:
+        case Binary_Op_Greater:
+        case Binary_Op_Greater_Equal:
             is_sign_significant = 1;
 
         default: break;
@@ -470,11 +470,11 @@ static void compile_binop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, A
     *pcode = code;
 }
 
-static void compile_unaryop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeUnaryOp* unop) {
+static void compile_unaryop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstUnaryOp* unop) {
     bh_arr(WasmInstruction) code = *pcode;
 
     switch (unop->operation) {
-        case ONYX_UNARY_OP_NEGATE:
+        case Unary_Op_Negate:
             {
                 TypeInfoKind type_kind = unop->base.type->kind;
 
@@ -501,24 +501,24 @@ static void compile_unaryop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode,
                 break;
             }
 
-        case ONYX_UNARY_OP_NOT:
+        case Unary_Op_Not:
             compile_expression(mod, &code, unop->expr);
 
             WI(WI_I32_EQZ);
             break;
 
-        case ONYX_UNARY_OP_CAST: compile_cast(mod, &code, unop); break;
+        case Unary_Op_Cast: compile_cast(mod, &code, unop); break;
     }
 
     *pcode = code;
 }
 
-static void compile_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeCall* call) {
+static void compile_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstCall* call) {
     bh_arr(WasmInstruction) code = *pcode;
 
-    for (AstNodeArgument *arg = call->arguments;
+    for (AstArgument *arg = call->arguments;
             arg != NULL;
-            arg = (AstNodeArgument *) arg->base.next) {
+            arg = (AstArgument *) arg->base.next) {
         compile_expression(mod, &code, arg->value);
     }
 
@@ -528,7 +528,7 @@ static void compile_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, As
     *pcode = code;
 }
 
-static void compile_intrinsic_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeIntrinsicCall* call) {
+static void compile_intrinsic_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstIntrinsicCall* call) {
     bh_arr(WasmInstruction) code = *pcode;
 
     i32 place_arguments_normally = 1;
@@ -538,9 +538,9 @@ static void compile_intrinsic_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)*
     if (0) place_arguments_normally = 0;
 
     if (place_arguments_normally) {
-        for (AstNodeArgument *arg = call->arguments;
+        for (AstArgument *arg = call->arguments;
                 arg != NULL;
-                arg = (AstNodeArgument *) arg->base.next) {
+                arg = (AstArgument *) arg->base.next) {
             compile_expression(mod, &code, arg->value);
         }
     }
@@ -599,20 +599,20 @@ static void compile_intrinsic_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)*
     *pcode = code;
 }
 
-static void compile_expression(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeTyped* expr) {
+static void compile_expression(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstTyped* expr) {
     bh_arr(WasmInstruction) code = *pcode;
 
     switch (expr->kind) {
-        case AST_NODE_KIND_BIN_OP:
-            compile_binop(mod, &code, (AstNodeBinOp *) expr);
+        case Ast_Kind_Binary_Op:
+            compile_binop(mod, &code, (AstBinaryOp *) expr);
             break;
 
-        case AST_NODE_KIND_UNARY_OP:
-            compile_unaryop(mod, &code, (AstNodeUnaryOp *) expr);
+        case Ast_Kind_Unary_Op:
+            compile_unaryop(mod, &code, (AstUnaryOp *) expr);
             break;
 
-        case AST_NODE_KIND_LOCAL:
-        case AST_NODE_KIND_PARAM:
+        case Ast_Kind_Local:
+        case Ast_Kind_Param:
             {
                 i32 localidx = (i32) bh_imap_get(&mod->local_map, (u64) expr);
 
@@ -620,7 +620,7 @@ static void compile_expression(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pco
                 break;
             }
 
-        case AST_NODE_KIND_GLOBAL:
+        case Ast_Kind_Global:
             {
                 i32 globalidx = (i32) bh_imap_get(&mod->global_map, (u64) expr);
 
@@ -628,9 +628,9 @@ static void compile_expression(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pco
                 break;
             }
 
-        case AST_NODE_KIND_LITERAL:
+        case Ast_Kind_Literal:
             {
-                AstNodeNumLit* lit = (AstNodeNumLit *) expr;
+                AstNumLit* lit = (AstNumLit *) expr;
                 WasmType lit_type = onyx_type_to_wasm_type(lit->base.type);
                 WasmInstruction instr = { WI_NOP, 0 };
 
@@ -652,15 +652,15 @@ static void compile_expression(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pco
                 break;
             }
 
-        case AST_NODE_KIND_BLOCK: compile_block(mod, &code, (AstNodeBlock *) expr); break;
+        case Ast_Kind_Block: compile_block(mod, &code, (AstBlock *) expr); break;
 
 
-        case AST_NODE_KIND_CALL:
-            compile_call(mod, &code, (AstNodeCall *) expr);
+        case Ast_Kind_Call:
+            compile_call(mod, &code, (AstCall *) expr);
             break;
 
-        case AST_NODE_KIND_INTRINSIC_CALL:
-            compile_intrinsic_call(mod, &code, (AstNodeIntrinsicCall *) expr);
+        case Ast_Kind_Intrinsic_Call:
+            compile_intrinsic_call(mod, &code, (AstIntrinsicCall *) expr);
             break;
 
         default:
@@ -682,7 +682,7 @@ static const WasmInstructionType cast_map[][6] = {
     /* F64 */ { WI_I32_FROM_F64_S, WI_I32_FROM_F64_U, WI_I64_FROM_F64_S, WI_I64_FROM_F64_U, WI_F32_FROM_F64,   WI_NOP,           },
 };
 
-static void compile_cast(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeUnaryOp* cast) {
+static void compile_cast(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstUnaryOp* cast) {
     bh_arr(WasmInstruction) code = *pcode;
 
     compile_expression(mod, &code, cast->expr);
@@ -719,7 +719,7 @@ static void compile_cast(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, As
     *pcode = code;
 }
 
-static void compile_return(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeReturn* ret) {
+static void compile_return(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstReturn* ret) {
     bh_arr(WasmInstruction) code = *pcode;
 
     if (ret->expr) {
@@ -731,18 +731,18 @@ static void compile_return(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode,
     *pcode = code;
 }
 
-static i32 generate_type_idx(OnyxWasmModule* mod, AstNodeFunction* fd) {
+static i32 generate_type_idx(OnyxWasmModule* mod, AstFunction* fd) {
     static char type_repr_buf[128];
 
     char* t = type_repr_buf;
-    AstNodeLocal* param = fd->params;
+    AstLocal* param = fd->params;
     i32 param_count = 0;
     while (param) {
         // HACK: Using these directly as part of a string feels weird but they are
         // valid characters so I don't think it is going to be much of an issue
         *(t++) = (char) onyx_type_to_wasm_type(param->base.type);
         param_count++;
-        param = (AstNodeLocal *) param->base.next;
+        param = (AstLocal *) param->base.next;
     }
     *(t++) = ':';
 
@@ -773,9 +773,9 @@ static i32 generate_type_idx(OnyxWasmModule* mod, AstNodeFunction* fd) {
     return type_idx;
 }
 
-static void compile_function(OnyxWasmModule* mod, AstNodeFunction* fd) {
+static void compile_function(OnyxWasmModule* mod, AstFunction* fd) {
     // NOTE: Don't compile intrinsics
-    if (fd->base.flags & ONYX_AST_FLAG_INTRINSIC) return;
+    if (fd->base.flags & Ast_Flag_Intrinsic) return;
 
     i32 type_idx = generate_type_idx(mod, fd);
 
@@ -792,7 +792,7 @@ static void compile_function(OnyxWasmModule* mod, AstNodeFunction* fd) {
 
     bh_arr_new(mod->allocator, wasm_func.code, 4);
 
-    if (fd->base.flags & ONYX_AST_FLAG_EXPORTED) {
+    if (fd->base.flags & Ast_Flag_Exported) {
         onyx_token_null_toggle(fd->base.token);
 
         i32 func_idx = (i32) bh_imap_get(&mod->func_map, (u64) fd);
@@ -811,7 +811,7 @@ static void compile_function(OnyxWasmModule* mod, AstNodeFunction* fd) {
     if (fd->body != NULL) {
         // NOTE: Generate the local map
         i32 localidx = 0;
-        for (AstNodeLocal *param = fd->params; param != NULL; param = (AstNodeLocal *) param->base.next) {
+        for (AstLocal *param = fd->params; param != NULL; param = (AstLocal *) param->base.next) {
             bh_imap_put(&mod->local_map, (u64) param, localidx++);
         }
 
@@ -821,7 +821,7 @@ static void compile_function(OnyxWasmModule* mod, AstNodeFunction* fd) {
         // is the same as the order of the local_types above
         u8* count = &wasm_func.locals.i32_count;
         fori (ti, 0, 3) {
-            forll (AstNodeLocal, local, fd->body->locals->last_local, prev_local) {
+            forll (AstLocal, local, fd->body->locals->last_local, prev_local) {
                 if (onyx_type_to_wasm_type(local->base.type) == local_types[ti]) {
                     bh_imap_put(&mod->local_map, (u64) local, localidx++);
 
@@ -846,10 +846,10 @@ static void compile_function(OnyxWasmModule* mod, AstNodeFunction* fd) {
     bh_imap_clear(&mod->local_map);
 }
 
-static void compile_global_declaration(OnyxWasmModule* module, AstNodeGlobal* global) {
+static void compile_global_declaration(OnyxWasmModule* module, AstGlobal* global) {
     WasmGlobal glob = {
         .type = onyx_type_to_wasm_type(global->base.type),
-        .mutable = (global->base.flags & ONYX_AST_FLAG_CONST) == 0,
+        .mutable = (global->base.flags & Ast_Flag_Const) == 0,
         .initial_value = NULL,
     };
 
@@ -861,7 +861,7 @@ static void compile_global_declaration(OnyxWasmModule* module, AstNodeGlobal* gl
         return;
     }
 
-    if ((global->base.flags & ONYX_AST_FLAG_EXPORTED) != 0) {
+    if ((global->base.flags & Ast_Flag_Exported) != 0) {
         onyx_token_null_toggle(global->base.token);
 
         i32 global_idx = (i32) bh_imap_get(&module->func_map, (u64) global);
@@ -880,9 +880,9 @@ static void compile_global_declaration(OnyxWasmModule* module, AstNodeGlobal* gl
     bh_arr_push(module->globals, glob);
 }
 
-static void compile_foreign(OnyxWasmModule* module, AstNodeForeign* foreign) {
-    if (foreign->import->kind == AST_NODE_KIND_FUNCTION) {
-        i32 type_idx = generate_type_idx(module, (AstNodeFunction *) foreign->import);
+static void compile_foreign(OnyxWasmModule* module, AstForeign* foreign) {
+    if (foreign->import->kind == Ast_Kind_Function) {
+        i32 type_idx = generate_type_idx(module, (AstFunction *) foreign->import);
 
         WasmImport import = {
             .kind = WASM_FOREIGN_FUNCTION,
@@ -893,8 +893,8 @@ static void compile_foreign(OnyxWasmModule* module, AstNodeForeign* foreign) {
 
         bh_arr_push(module->imports, import);
 
-    } else if (foreign->import->kind == AST_NODE_KIND_GLOBAL) {
-        WasmType global_type = onyx_type_to_wasm_type(((AstNodeGlobal *) foreign->import)->base.type);
+    } else if (foreign->import->kind == Ast_Kind_Global) {
+        WasmType global_type = onyx_type_to_wasm_type(((AstGlobal *) foreign->import)->base.type);
 
         WasmImport import = {
             .kind = WASM_FOREIGN_GLOBAL,
@@ -959,14 +959,14 @@ OnyxWasmModule onyx_wasm_module_create(bh_allocator alloc, OnyxMessages* msgs) {
 void onyx_wasm_module_compile(OnyxWasmModule* module, OnyxProgram* program) {
 
     // NOTE: First, introduce all indicies for globals and functions
-    bh_arr_each(AstNodeForeign *, foreign, program->foreigns) {
-        AstNodeKind import_kind = (*foreign)->import->kind;
+    bh_arr_each(AstForeign *, foreign, program->foreigns) {
+        AstKind import_kind = (*foreign)->import->kind;
 
-        if (import_kind == AST_NODE_KIND_FUNCTION) {
+        if (import_kind == Ast_Kind_Function) {
             module->next_func_idx++;
             bh_imap_put(&module->func_map, (u64) (*foreign)->import, module->next_import_func_idx++);
         }
-        else if (import_kind == AST_NODE_KIND_GLOBAL) {
+        else if (import_kind == Ast_Kind_Global) {
             module->next_global_idx++;
             bh_imap_put(&module->global_map, (u64) (*foreign)->import, module->next_import_global_idx++);
         }
@@ -974,20 +974,20 @@ void onyx_wasm_module_compile(OnyxWasmModule* module, OnyxProgram* program) {
         compile_foreign(module, *foreign);
     }
 
-    bh_arr_each(AstNodeFunction *, function, program->functions) {
-        if (((*function)->base.flags & ONYX_AST_FLAG_INTRINSIC) == 0)
+    bh_arr_each(AstFunction *, function, program->functions) {
+        if (((*function)->base.flags & Ast_Flag_Intrinsic) == 0)
             bh_imap_put(&module->func_map, (u64) *function, module->next_func_idx++);
     }
 
-    bh_arr_each(AstNodeGlobal *, global, program->globals)
+    bh_arr_each(AstGlobal *, global, program->globals)
         bh_imap_put(&module->global_map, (u64) *global, module->next_global_idx++);
 
 
     // NOTE: Then, compile everything
-    bh_arr_each(AstNodeFunction *, function, program->functions)
+    bh_arr_each(AstFunction *, function, program->functions)
         compile_function(module, *function);
 
-    bh_arr_each(AstNodeGlobal *, global, program->globals)
+    bh_arr_each(AstGlobal *, global, program->globals)
         compile_global_declaration(module, *global);
 }
 
-- 
2.25.1