From 85adad9831c714c391c51adbaba45a52a89137fa Mon Sep 17 00:00:00 2001
From: Simon <sfja.skp@edu.mercantec.dk>
Date: Sat, 11 Feb 2023 18:59:19 +0000
Subject: [PATCH] init

---
 '                 |  36 +++++
 :w                | 187 ++++++++++++++++++++++++
 LICENSE           |   9 ++
 Makefile          |  19 +++
 README.md         |   2 +
 compile_flags.txt |   6 +
 lexer.c           | 353 ++++++++++++++++++++++++++++++++++++++++++++++
 lexer.h           |  76 ++++++++++
 lexer.o           | Bin 0 -> 17072 bytes
 main.c            |   3 +
 main.o            | Bin 0 -> 1496 bytes
 wacc              | Bin 0 -> 20744 bytes
 12 files changed, 691 insertions(+)
 create mode 100644 '
 create mode 100644 :w
 create mode 100644 LICENSE
 create mode 100644 Makefile
 create mode 100644 README.md
 create mode 100644 compile_flags.txt
 create mode 100644 lexer.c
 create mode 100644 lexer.h
 create mode 100644 lexer.o
 create mode 100644 main.c
 create mode 100644 main.o
 create mode 100755 wacc

diff --git a/' b/'
new file mode 100644
index 0000000..2ee068e
--- /dev/null
+++ b/'
@@ -0,0 +1,36 @@
+#ifndef LEXER_H
+#define LEXER_H
+
+#include <stddef.h>
+
+typedef enum {
+    Id,
+    Int,
+    Float,
+    String,
+
+    If,
+    Else,
+    While,
+    Break,
+
+    LParen,
+    RParen,
+    LBrace,
+    RBrace,
+
+    Plus,
+    Minus,
+} TokenType;
+
+typedef struct {
+    TokenType type;
+    size_t index, length;
+    int line, column;
+} Token;
+
+typedef struct Lexer Lexer;
+
+void lexer_create(Lexer* lexer, const char* text, size_t text_length);
+
+#endif
diff --git a/:w b/:w
new file mode 100644
index 0000000..eb0d0d5
--- /dev/null
+++ b/:w
@@ -0,0 +1,187 @@
+#include "lexer.h"
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct Lexer {
+    const char* text;
+    size_t index, length;
+    int line, column;
+};
+
+Token lexer_skip_whitespace(Lexer* lexer);
+Token lexer_make_int(Lexer* lexer);
+Token lexer_make_id(Lexer* lexer);
+bool lexer_span_matches(const Lexer* lexer, Position begin, const char* value);
+Token lexer_make_static(Lexer* lexer);
+Token make_single_char_token(Lexer* lexer, TokenType type);
+Token make_slash_token(Lexer* lexer);
+Token lexer_make_invalid_char(Lexer* lexer);
+Position lexer_position(const Lexer* lexer);
+Token lexer_token(const Lexer* lexer, TokenType type, Position begin);
+bool lexer_done(const Lexer* lexer);
+char lexer_current(const Lexer* lexer);
+void lexer_step(Lexer* lexer);
+
+void lexer_create(Lexer* lexer, const char* text, size_t text_length)
+{
+    *lexer = (Lexer) {
+        .text = text,
+        .length = text_length,
+        .line = 1,
+        .column = 1,
+    };
+}
+
+Token lexer_next(Lexer* lexer)
+{
+    char c = lexer_current(lexer);
+    if (lexer_done(lexer))
+        return lexer_token(lexer, TokenTypeEof, lexer_position(lexer));
+    else if (isspace(c))
+        return lexer_skip_whitespace(lexer);
+    else if (isdigit(c))
+        return lexer_make_int(lexer);
+    else if (isalpha(c) || c == '_')
+        return lexer_make_id(lexer);
+    else
+        return lexer_make_static(lexer);
+}
+
+Token lexer_skip_whitespace(Lexer* lexer)
+{
+    lexer_step(lexer);
+    while (!lexer_done(lexer) && isspace(lexer_current(lexer)))
+        lexer_step(lexer);
+    return lexer_next(lexer);
+}
+
+Token lexer_make_int(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    while (!lexer_done(lexer) && isdigit(lexer_current(lexer)))
+        lexer_step(lexer);
+    return lexer_token(lexer, TokenTypeInt, begin);
+}
+
+Token lexer_make_id(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    while (!lexer_done(lexer)
+        && (isalpha(lexer_current(lexer)) || isdigit(lexer_current(lexer))
+            || lexer_current(lexer) == '_'))
+        lexer_step(lexer);
+    if (lexer_span_matches(lexer, begin, "if"))
+        return lexer_token(lexer, TokenTypeIf, begin);
+    else if (lexer_span_matches(lexer, begin, "else"))
+        return lexer_token(lexer, TokenTypeElse, begin);
+    else if (lexer_span_matches(lexer, begin, "while"))
+        return lexer_token(lexer, TokenTypeWhile, begin);
+    else if (lexer_span_matches(lexer, begin, "break"))
+        return lexer_token(lexer, TokenTypeBreak, begin);
+    else
+        return lexer_token(lexer, TokenTypeId, begin);
+}
+
+bool lexer_span_matches(const Lexer* lexer, Position begin, const char* value)
+{
+    size_t length = lexer->index - begin.index;
+    if (length != strlen(value))
+        return false;
+    return strncmp(&lexer->text[begin.index], value, length) == 0;
+}
+
+Token lexer_make_static(Lexer* lexer)
+{
+    switch (lexer_current(lexer)) {
+        case '(':
+            return make_single_char_token(lexer, TokenTypeLParen);
+        case ')':
+            return make_single_char_token(lexer, TokenTypeRParen);
+        case '{':
+            return make_single_char_token(lexer, TokenTypeLBrace);
+        case '}':
+            return make_single_char_token(lexer, TokenTypeRBrace);
+        case ';':
+            return make_single_char_token(lexer, TokenTypeSemicolon);
+        case '+':
+            return make_single_char_token(lexer, TokenTypePlus);
+        case '-':
+            return make_single_char_token(lexer, TokenTypeMinus);
+        case '*':
+            return make_single_char_token(lexer, TokenTypeAsterisk);
+        case '/':
+            return make_slash_token(lexer);
+        case '%':
+            return make_single_char_token(lexer, TokenTypePercent);
+        default:
+            return lexer_make_invalid_char(lexer);
+    }
+}
+
+Token make_single_char_token(Lexer* lexer, TokenType type)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    return lexer_token(lexer, type, begin);
+}
+
+Token skip_singleline_comment(Lexer* lexer);
+Token skip_multiline_comment(Lexer* lexer);
+
+Token make_slash_token(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    switch (lexer_current(lexer)) {
+        case '/':
+            return skip_singleline_comment(lexer);
+        default:
+            return lexer_token(lexer, TokenTypeSlash, begin);
+    }
+}
+
+Token lexer_make_invalid_char(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    return lexer_token(lexer, TokenTypeInvalidChar, begin);
+}
+
+Position lexer_position(const Lexer* lexer)
+{
+    return (Position) {
+        .index = lexer->index,
+        .line = lexer->line,
+        .column = lexer->column,
+    };
+}
+
+Token lexer_token(const Lexer* lexer, TokenType type, Position begin)
+{
+    return (Token) {
+        .type = type,
+        .position = begin,
+        .length = lexer->index - begin.index,
+    };
+}
+
+bool lexer_done(const Lexer* lexer) { return lexer->index >= lexer->length; }
+
+char lexer_current(const Lexer* lexer) { return lexer->text[lexer->index]; }
+
+void lexer_step(Lexer* lexer)
+{
+    if (lexer_done(lexer))
+        return;
+    if (lexer_current(lexer) == '\n') {
+        lexer->line += 1;
+        lexer->column = 1;
+    } else {
+        lexer->column += 1;
+    }
+    lexer->index += 1;
+}
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..2071b23
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..ac5288e
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,19 @@
+
+CFLAGS = -std=c17 -Wall -Wextra -Wpedantic -Wconversion
+
+HEADERS = $(wildcard *.h)
+
+all: compile_flags.txt wacc
+
+wacc: main.o lexer.o
+	gcc $^ -o $@
+
+%.o: %.c $(HEADERS)
+	gcc $< -c -o $@ $(CFLAGS)
+
+clean:
+	rm -rf *.o wacc
+
+compile_flags.txt:
+	echo -xc $(CFLAGS) | sed 's/\s\+/\n/g' > compile_flags.txt
+
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..31c53b6
--- /dev/null
+++ b/README.md
@@ -0,0 +1,2 @@
+# wacc
+
diff --git a/compile_flags.txt b/compile_flags.txt
new file mode 100644
index 0000000..083ed44
--- /dev/null
+++ b/compile_flags.txt
@@ -0,0 +1,6 @@
+-xc
+-std=c17
+-Wall
+-Wextra
+-Wpedantic
+-Wconversion
diff --git a/lexer.c b/lexer.c
new file mode 100644
index 0000000..297c410
--- /dev/null
+++ b/lexer.c
@@ -0,0 +1,353 @@
+#include "lexer.h"
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct Lexer {
+    const char* text;
+    size_t index, length;
+    int line, column;
+};
+
+Token lexer_skip_whitespace(Lexer* lexer);
+Token lexer_make_int_or_float(Lexer* lexer);
+Token lexer_make_id(Lexer* lexer);
+bool lexer_span_matches(const Lexer* lexer, Position begin, const char* value);
+Token lexer_make_static_token(Lexer* lexer);
+Token lexer_make_int_hex_or_binary(Lexer* lexer);
+Token lexer_make_char(Lexer* lexer);
+Token lexer_make_string(Lexer* lexer);
+void lexer_skip_literal_char(Lexer* lexer);
+Token lexer_make_single_char_token(Lexer* lexer, TokenType type);
+Token lexer_make_slash_token(Lexer* lexer);
+Token lexer_skip_singleline_comment(Lexer* lexer);
+Token lexer_make_single_or_double_char_token(
+    Lexer* lexer, TokenType single_type, char second_char, TokenType double_type);
+Token lexer_skip_multiline_comment(Lexer* lexer);
+Token lexer_make_invalid_char(Lexer* lexer);
+Position lexer_position(const Lexer* lexer);
+Token lexer_token(const Lexer* lexer, TokenType type, Position begin);
+bool lexer_done(const Lexer* lexer);
+char lexer_current(const Lexer* lexer);
+void lexer_step(Lexer* lexer);
+
+void lexer_create(Lexer* lexer, const char* text, size_t text_length)
+{
+    *lexer = (Lexer) {
+        .text = text,
+        .length = text_length,
+        .line = 1,
+        .column = 1,
+    };
+}
+
+Token lexer_next(Lexer* lexer)
+{
+    char c = lexer_current(lexer);
+    if (lexer_done(lexer))
+        return lexer_token(lexer, TokenTypeEof, lexer_position(lexer));
+    else if (isspace(c))
+        return lexer_skip_whitespace(lexer);
+    else if (c >= '1' && c <= '9')
+        return lexer_make_int_or_float(lexer);
+    else if (isalpha(c) || c == '_')
+        return lexer_make_id(lexer);
+    else
+        return lexer_make_static_token(lexer);
+}
+
+Token lexer_skip_whitespace(Lexer* lexer)
+{
+    lexer_step(lexer);
+    while (!lexer_done(lexer) && isspace(lexer_current(lexer)))
+        lexer_step(lexer);
+    return lexer_next(lexer);
+}
+
+Token lexer_make_int_or_float(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    while (!lexer_done(lexer) && isdigit(lexer_current(lexer)))
+        lexer_step(lexer);
+    if (!lexer_done(lexer) && lexer_current(lexer) == '.') {
+        while (!lexer_done(lexer) && isdigit(lexer_current(lexer)))
+            lexer_step(lexer);
+        return lexer_token(lexer, TokenTypeFloat, begin);
+    } else {
+        return lexer_token(lexer, TokenTypeInt, begin);
+    }
+}
+
+Token lexer_make_id(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    while (!lexer_done(lexer)
+        && (isalpha(lexer_current(lexer)) || isdigit(lexer_current(lexer))
+            || lexer_current(lexer) == '_'))
+        lexer_step(lexer);
+    if (lexer_span_matches(lexer, begin, "if"))
+        return lexer_token(lexer, TokenTypeIf, begin);
+    else if (lexer_span_matches(lexer, begin, "else"))
+        return lexer_token(lexer, TokenTypeElse, begin);
+    else if (lexer_span_matches(lexer, begin, "while"))
+        return lexer_token(lexer, TokenTypeWhile, begin);
+    else if (lexer_span_matches(lexer, begin, "break"))
+        return lexer_token(lexer, TokenTypeBreak, begin);
+    else
+        return lexer_token(lexer, TokenTypeId, begin);
+}
+
+bool lexer_span_matches(const Lexer* lexer, Position begin, const char* value)
+{
+    size_t length = lexer->index - begin.index;
+    if (length != strlen(value))
+        return false;
+    return strncmp(&lexer->text[begin.index], value, length) == 0;
+}
+
+Token lexer_make_static_token(Lexer* lexer)
+{
+    switch (lexer_current(lexer)) {
+        case '0':
+            return lexer_make_int_hex_or_binary(lexer);
+        case '\'':
+            return lexer_make_char(lexer);
+        case '"':
+            return lexer_make_string(lexer);
+        case '(':
+            return lexer_make_single_char_token(lexer, TokenTypeLParen);
+        case ')':
+            return lexer_make_single_char_token(lexer, TokenTypeRParen);
+        case '{':
+            return lexer_make_single_char_token(lexer, TokenTypeLBrace);
+        case '}':
+            return lexer_make_single_char_token(lexer, TokenTypeRBrace);
+        case '[':
+            return lexer_make_single_char_token(lexer, TokenTypeLBracket);
+        case ']':
+            return lexer_make_single_char_token(lexer, TokenTypeRBracket);
+        case '.':
+            return lexer_make_single_char_token(lexer, TokenTypeDot);
+        case ',':
+            return lexer_make_single_char_token(lexer, TokenTypeComma);
+        case ':':
+            return lexer_make_single_char_token(lexer, TokenTypeColon);
+        case ';':
+            return lexer_make_single_char_token(lexer, TokenTypeSemicolon);
+        case '+':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypePlus, '=', TokenTypePlusEqual);
+        case '-':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypeMinus, '=', TokenTypeMinusEqual);
+        case '*':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypeAsterisk, '=', TokenTypeAsteriskEqual);
+        case '/':
+            return lexer_make_slash_token(lexer);
+        case '%':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypePercent, '=', TokenTypePercentEqual);
+        case '=':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypeEqual, '=', TokenTypeDoubleEqual);
+        case '!':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypeExclamation, '=', TokenTypeExclamationEqual);
+        case '<':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypeLt, '=', TokenTypeLtEqual);
+        case '>':
+            return lexer_make_single_or_double_char_token(
+                lexer, TokenTypeGt, '=', TokenTypeGtEqual);
+        default:
+            return lexer_make_invalid_char(lexer);
+    }
+}
+
+Token lexer_make_int_hex_or_binary(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    if (!lexer_done(lexer) && (lexer_current(lexer) == 'x' || lexer_current(lexer) == 'X')) {
+        while (!lexer_done(lexer)
+            && (isdigit(lexer_current(lexer))
+                || (lexer_current(lexer) >= 'a' || lexer_current(lexer) <= 'f')
+                || (lexer_current(lexer) >= 'A' || lexer_current(lexer) <= 'F')))
+            lexer_step(lexer);
+        return lexer_token(lexer, TokenTypeHex, begin);
+    } else if (!lexer_done(lexer) && (lexer_current(lexer) == 'b' || lexer_current(lexer) == 'B')) {
+        while (!lexer_done(lexer) && (lexer_current(lexer) == '0' || lexer_current(lexer) == '1'))
+            lexer_step(lexer);
+        return lexer_token(lexer, TokenTypeBinary, begin);
+    } else {
+        return lexer_token(lexer, TokenTypeInt, begin);
+    }
+}
+
+Token lexer_make_char(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    if (lexer_done(lexer))
+        return lexer_token(lexer, TokenTypeMalformedChar, begin);
+    lexer_skip_literal_char(lexer);
+    if (lexer_done(lexer) && lexer_current(lexer) != '\'')
+        return lexer_token(lexer, TokenTypeMalformedChar, begin);
+    lexer_step(lexer);
+    return lexer_token(lexer, TokenTypeChar, begin);
+}
+
+Token lexer_make_string(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    if (lexer_done(lexer))
+        return lexer_token(lexer, TokenTypeMalformedString, begin);
+    while (!lexer_done(lexer) && lexer_current(lexer) != '\"')
+        lexer_skip_literal_char(lexer);
+    if (lexer_done(lexer) && lexer_current(lexer) != '\"')
+        return lexer_token(lexer, TokenTypeMalformedString, begin);
+    lexer_step(lexer);
+    return lexer_token(lexer, TokenTypeChar, begin);
+}
+
+void lexer_skip_literal_char(Lexer* lexer)
+{
+    if (lexer_current(lexer) == '\\') {
+        lexer_step(lexer);
+        if (!lexer_done(lexer) && lexer_current(lexer) == '0') {
+            lexer_step(lexer);
+        } else if (!lexer_done(lexer) && lexer_current(lexer) >= '1'
+            && lexer_current(lexer) <= '9') {
+            lexer_step(lexer);
+            while (!lexer_done(lexer) && isdigit(lexer_current(lexer)))
+                lexer_step(lexer);
+        } else if (!lexer_done(lexer)
+            && (lexer_current(lexer) == 'x' || lexer_current(lexer) == 'X')) {
+            lexer_step(lexer);
+            while (!lexer_done(lexer)
+                && (isdigit(lexer_current(lexer))
+                    || (lexer_current(lexer) >= 'a' && lexer_current(lexer) <= 'f')
+                    || (lexer_current(lexer) >= 'A' && lexer_current(lexer) <= 'F')))
+                lexer_step(lexer);
+        } else if (!lexer_done(lexer)) {
+            lexer_step(lexer);
+        }
+    } else {
+        lexer_step(lexer);
+    }
+}
+
+Token lexer_make_single_char_token(Lexer* lexer, TokenType type)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    return lexer_token(lexer, type, begin);
+}
+
+Token lexer_make_single_or_double_char_token(
+    Lexer* lexer, TokenType single_type, char second_char, TokenType double_type)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    if (!lexer_done(lexer) && lexer_current(lexer) == second_char) {
+        lexer_step(lexer);
+        return lexer_token(lexer, single_type, begin);
+    } else {
+        return lexer_token(lexer, double_type, begin);
+    }
+}
+
+Token lexer_make_slash_token(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    switch (lexer_current(lexer)) {
+        case '/':
+            return lexer_skip_singleline_comment(lexer);
+        case '*':
+            return lexer_skip_multiline_comment(lexer);
+        case '=':
+            lexer_step(lexer);
+            return lexer_token(lexer, TokenTypeSlashEqual, begin);
+        default:
+            return lexer_token(lexer, TokenTypeSlash, begin);
+    }
+}
+
+Token lexer_skip_singleline_comment(Lexer* lexer)
+{
+    lexer_step(lexer);
+    while (!lexer_done(lexer) && lexer_current(lexer) != '\n')
+        lexer_step(lexer);
+    if (!lexer_done(lexer) && lexer_current(lexer) == '\n')
+        lexer_step(lexer);
+    return lexer_next(lexer);
+}
+
+Token lexer_skip_multiline_comment(Lexer* lexer)
+{
+    lexer_step(lexer);
+    int depth = 1;
+    while (!lexer_done(lexer)) {
+        if (lexer_current(lexer) == '/') {
+            lexer_step(lexer);
+            if (!lexer_done(lexer) && lexer_current(lexer) == '*')
+                depth += 1;
+        } else if (lexer_current(lexer) == '*') {
+            lexer_step(lexer);
+            if (lexer_done(lexer) && lexer_current(lexer) == '/')
+                depth -= 1;
+        }
+        lexer_step(lexer);
+    }
+    return depth != 0
+        ? lexer_token(lexer, TokenTypeMalformedMultilineComment, lexer_position(lexer))
+        : lexer_next(lexer);
+}
+
+Token lexer_make_invalid_char(Lexer* lexer)
+{
+    Position begin = lexer_position(lexer);
+    lexer_step(lexer);
+    return lexer_token(lexer, TokenTypeInvalidChar, begin);
+}
+
+Position lexer_position(const Lexer* lexer)
+{
+    return (Position) {
+        .index = lexer->index,
+        .line = lexer->line,
+        .column = lexer->column,
+    };
+}
+
+Token lexer_token(const Lexer* lexer, TokenType type, Position begin)
+{
+    return (Token) {
+        .type = type,
+        .position = begin,
+        .length = lexer->index - begin.index,
+    };
+}
+
+bool lexer_done(const Lexer* lexer) { return lexer->index >= lexer->length; }
+
+char lexer_current(const Lexer* lexer) { return lexer->text[lexer->index]; }
+
+void lexer_step(Lexer* lexer)
+{
+    if (lexer_done(lexer))
+        return;
+    if (lexer_current(lexer) == '\n') {
+        lexer->line += 1;
+        lexer->column = 1;
+    } else {
+        lexer->column += 1;
+    }
+    lexer->index += 1;
+}
diff --git a/lexer.h b/lexer.h
new file mode 100644
index 0000000..1efce31
--- /dev/null
+++ b/lexer.h
@@ -0,0 +1,76 @@
+#ifndef LEXER_H
+#define LEXER_H
+
+#include <stddef.h>
+
+typedef enum {
+    TokenTypeEof,
+
+    TokenTypeInvalidChar,
+    TokenTypeMalformedMultilineComment,
+    TokenTypeMalformedChar,
+    TokenTypeMalformedString,
+
+    TokenTypeId,
+    TokenTypeInt,
+    TokenTypeHex,
+    TokenTypeBinary,
+    TokenTypeFloat,
+    TokenTypeChar,
+    TokenTypeString,
+
+    TokenTypeIf,
+    TokenTypeElse,
+    TokenTypeWhile,
+    TokenTypeBreak,
+
+    TokenTypeLParen,
+    TokenTypeRParen,
+    TokenTypeLBrace,
+    TokenTypeRBrace,
+    TokenTypeLBracket,
+    TokenTypeRBracket,
+    TokenTypeDot,
+    TokenTypeComma,
+    TokenTypeColon,
+    TokenTypeSemicolon,
+
+    TokenTypePlusEqual,
+    TokenTypeMinusEqual,
+    TokenTypeAsteriskEqual,
+    TokenTypeSlashEqual,
+    TokenTypePercentEqual,
+    TokenTypeDoubleEqual,
+    TokenTypeExclamationEqual,
+    TokenTypeLtEqual,
+    TokenTypeGtEqual,
+
+    TokenTypePlus,
+    TokenTypeMinus,
+    TokenTypeAsterisk,
+    TokenTypeSlash,
+    TokenTypePercent,
+    TokenTypeEqual,
+    TokenTypeExclamation,
+    TokenTypeLt,
+    TokenTypeGt,
+
+} TokenType;
+
+typedef struct {
+    size_t index;
+    int line, column;
+} Position;
+
+typedef struct {
+    TokenType type;
+    Position position;
+    size_t length;
+} Token;
+
+typedef struct Lexer Lexer;
+
+void lexer_create(Lexer* lexer, const char* text, size_t text_length);
+Token lexer_next(Lexer* lexer);
+
+#endif
diff --git a/lexer.o b/lexer.o
new file mode 100644
index 0000000000000000000000000000000000000000..e794c7304e590dd54d4f8a3bcaab12d4d2e651f8
GIT binary patch
literal 17072
zcmeI4f0R_^dB^YmKo^1z2&5aO>3{-@;<6y*03C7`W#yUxuF*{>VuxXOmYp#BgWWsI
zT7H?`MJ5|sa>6ls;xV?>N=}m2B&cAF4iRCs)Gjs2*;do8rzY;6fr@Ep7aO~Mo_nA7
z&UYT>f~f6ZeUG#EzMtoLpZ9s6_s6~Wy%%@Xth~9nsK_#@$oj06%Nc4}r$3uJuXazX
zt&nxORcEJvWv90d*y&Wiov!P%dus+7L+@ll6Rpt1>Is~+d+SJKPW$Y1t$Ti~x|}Ow
zjbqhQ`E>7HFS5DY?XHs*#%6=vTRNkH_0ly%^D?AOwvG+42fJ(D#%y=SnTvV5m%Tb{
zr(a`wOS=DAE@Y>Vx`l`LQ^q~Bdo4TkeBIl2(LdNl{h?>9&@-7CR@kz7GR_n#D*pe%
zRGZzrbKBch+pnU(i+2=Ms6CI}Qns7AgbGJf1q)9qP$i+E2KzcM5Y8Ae&z{{i^72K+
zEIXcqVVZ*HU8jpEg4c`fauiW`GIkODH;@;d)B#e`(INB!TwO%nO9LU5Ik$T=zH@1I
zw2msM@tNzspF_#H?&s9balg#%1a{w7a?6LhyLgBIj#Q>PKK4p!lF*Fc;n|xa2Tt6Q
z9(i`GJ2t(6oxPe|D5P`=D3MB`KvOXs6aQO*Zh>*)$MD>7;*ItLA57WnmHYF;9}RVP
zjE;^{peSH67WQ05VX(|Fp+Q>_5U%l{HvAjTd?+(qovCg3yB9PwBfy)>!Ay4J`CSRJ
z5keb5qht&yU3iqxVp~PCamY@ew$rr8{e~7=Z{DR>4RUe2x3-Lq{r2pi(sUf5(?Jsr
zdvVQ(bLl~<&&tm7ba`p-xA%-MrtT8mqjvi5-4W1}3GK^x>lM`+_G(QH;u<jGF7bW^
zG;_O#rge?13*Db7wybo<-ZQy}tF!lTE3MwrV*5dR&lDFG^^c0fb!5O_uZJI^lAd$<
z{JsF5@cF92XD4uF=~qpQhgYI-q7u$U;T1}F1qvrA;TgLAc|KB|la+7)h1^zj=*KAh
zq!K=Y!rxQE`%qY}gbgVCloGD+g{i@12d^aQp{4Za*{fYWZxI`wo~Lw`uXGJ6z0VnU
zkg=tyzS0a-8t|3!J22yOF8pcAd2Y;NE;k9o-^x?^17E2El(L;UAHu%IY}EKtPGg#{
zaV=^r%xO&bHLgPqzO>VH%4-Cnkph?Yq1<Kt!!F@uIb)(ASGRv=ZvaQOIMeg;YeGGI
zmvo^k-sX#0(DN>{k@Y(s%d4?*`@Xz<^^Wem{LP_1ZF4UG1uuw~LU@NWs&&%nT?$7w
zIG@g|;>J|tg&G{rD^TT}$ji@j4pY9bz*U_tY5qw3n6B!wUem2@s{h=TlU8nT`q3&r
zNXs=1H(t$!!MR*E=@x{BV=pcLd};J<MM}Ww;hkRef^6`h_hpe;4qvz~WHYO7(+d_D
z2TqX9LUUxmzm!xJdRp)<CBAbXARr3@oTs}OzZZx9@;m|YZbH3Fpu{{fJ;j5?cZ1@d
zAG7I!F~e#<=9uv#R=Ioq<rT@ex-Qi7PiE214H;kVwQd@<#z&E=)I`h=e@~T{IViW)
zP;Pq%mWwRjQIC0dKKj}y5rfrK4=h4C)qs2bCx<UD>{*}JoxTBD5+`GQ5n2)-Q#u#)
z?r|z`QQqa%xPCj2pqxjI+xO<>tGC;Ed0HZqv_xj-BlS9q*Dc>r_KLh*>E3M7Ub1W+
z7idUSn|YM3JAUzN3(b4JW85~>TX&q76MC#MLyIat{|v^O(|ya+HAi;W^j*9Q{xtKN
zzm)3r(W08Z)EoqKejb;ze31b8k&A6ol?moYXa?W^jx2Q+)1Mvju90h<E4xPKrtb7S
z<6Ra1E;pMf1n(f|2S60`a{v20x@Ee%*C=ZAIoE`lphR}g-<e@|Wl5j+&fc9vgQi|G
z>7RRD$5X&Zk#X)K>gPR`sY->nHhdL2r)%0p-fC48>N2(KbgbqrT1l+ouX98ox{<l5
zyoDWQp1)s26uCBaa~GM)Rx4VCc|4~p2d_+icT$C=UCnP5A;WXG(ooMDS{k~xy=6IS
z?CZ@jdOESp=2*7SCX~Af6}VNU;Q~v@M;P^m#vO+m2FZEG-R<t6>s>{?zPXH6qM_xz
z%gXuK+c}k<ZI`Ey(iWh7i0oMuk<pdY4%=hjwbQSp&)SFI4AV?X|Az;lIkK-wtD&9l
zTgiKguh4D8lXPEo(2cbBWK8*A*t3rk8K9MqH#%2QQ%J3s)Y8k!?DTEKXe~*%kwY~D
z-YzG(J3=}7xsTU$q}|fRKMj2&qvc$f#bvxb`LreCu9IX~Ovvo*&ZO#GU2{Pnm*Pci
zq_?_!Pc4s=k#uc2A7sBZ%hzs_PW7ccrM#*H(PnKKT_#?BG0|wnlO1vEo~A@HZf$6f
z$2M^&|3Cd-M_|QGH!TTQtXN$)J3McG<^0Nd;rUhbZ>XAIHP7{gZyLk&<LwbrvWl&u
z3^SfcoQfpR`;DA<uYpt1y<f13woE9xYW$^Tdr6re#renSR{pc>@(H_&Z@TP~;?I$W
zS4V_7r3Gx<$ZNVvO0F&Pb=I>2CEhnfo#H=tRa{@YSw<<L?L>2S_IoPUOkSt3uBpYY
zA@=pS=-kamqf@-um!A~*EPlc<@{;K#tPmzNp6jPHN!KwpS4WlTOhjKx#=DNP549rC
zi%H2`R~{yLo5&~YI>zPd*e5#olD_X}amsJU0g=C!Cx6wK|4iiX<;l<Z^52Tw-MBMx
zDE^Tv4^tV}H##n7JtOCSUE=izw{sEuPiZUvF*?Qf_%_yv{C1Qt>nbT;<*K-2Ypdwo
zg*wG+d_Nx+c^Kt)=E^@Oa^BSOeOQ~5zaer5<;AU@0<!{%n_OzWJ6b?wmH4wLUs~eM
zwtU9(>k80!=MXX8p<{0H3#2cm39obaGA+w(6S29%7YYwkp3@Tgv7H{7z;2w0-6DKI
zxEotyb@b!COr7cpu$?aP!=0zZI)ztC4Bfd&jBk5b|C>CAD7o{Ij^Cyq^Bedb1toWm
z(eWAj6{?q?yI9|mcDa2-jK?(dpSb(GmgUZ6V!x(eAv>o6_!+UYRu(#UPBWu+vi;^y
zP==B_kLk#}mCU#EO9M)#U--!UXvpL4oTSs+gjb7G?p!3kMffD%8>ZyWK|21K@UhY_
z?z|!Xgzz7_FEw&=?*-wP@isCgcdpX$m%?8X?#@wGNXECs+biq6W3-+w&`w-3E%7am
z;i>lac#Fw3w6++Xw$_e>lW1)bJ*Rb3yv2$}>z&TFcyvQF*=j6zY)Z66=`O&DceKUo
zP4VW~rg${b;zV29qm9Ydn5n_z4Pw>JbvQ96Q6DumP_}+kw7zLmv@w=QieiToZ!@QD
zv6g6a%&BjRcUT=xdy@R3LrZ<L(eUeTif`fiHzZnO?VVU<eN(I*^He_3vN4ZPJ{c!B
zV(sFY8&9g3+STC+$#g?&YD2JEGS<;_Zs|nJ-LYh%!L@DL#4$`#2-{=HbGTPqGSNcr
zv^F>AddrP`b1La1@`T*^mUWMJptZ}gcnbcGZ*nQ^0?xaohCcwDF6TZ!0Gy|e(SIH|
z@68$hZ@_s<86Ki>%8C8qDP{O4fuo(3z<DYd{TOh5gJyUNI8RN(zYCnFrs0PI_)EYs
zJ|}>qpM$_L&f{gB<o5E?W$FzBM?b#^9OM6G;OPIB0NxE8{oe~5{r@&_^#2HOwDUS}
z)IS9r{X7dC?TnG@1;+>dnG785*8<0Jm<r%&;27r@fMc9r1CIW`8Ng2g$9A0sj_oSr
zhEn1KwreJE)L#f3_16aQlyD9=yI{uKHqhrwkl~L3$9O)c?0Boj=;#s9M>|>IXs1N3
z*Tx@Fvpyl5^Jr&2aI~{R+2I&*x)t=%&fUP#&bI>i-vGyPauzsWT20(4xHBlR|C8uv
z_*&rDU-t?(ap1AVX;%P$1nlswfwBKIaK1${{8iw5FKKudIKSvMyo?7cCH5cri~xRP
z0FMUntpWU@0RD6Ue=UHY4&YOGGE?Gq@w;o&-X#G%8o=)X&ab(Rori&={lfwLUjz6U
z9+Z@{pR)pZ1o)Ly&iGRc9LMcffU^rm{{i5*zWoJo4z1BY1e}MG;V%d9e*up6v%t~*
ze*(vK?-H5d93QOrx&Z!%0sQj;{LTQr3pl%G+WSr5=>J~>M?aqr;QhccK5qa=`|kip
z`=bGTraZrJ+|d8e2k<Cx96$Sj<M`PR9Q{849Q}VCIQnxEIDZ3T;yeNz?Uc#$mmUvu
zfusGUz|qh3z){};j&XP#IL6@+aJ2staP<EqaIE)z;24Lo^4!PmMLSc0<9L_@9Q7l>
zQNJEI`m-50wrd}7)ZY&r<8}-<*84hewEs46^#48JXlESX^i$&apq;CLqn-J{(awzl
z{0qR*{`vr(1djD?1<q5}jPqXL=+9HY(av$;sQ*R)KMfrH|L*`kjysQ%9&c9yNB?I7
zM}Jla@IMaVEdhLc0N)23<MRY?Z0}P6{4{W!*QH!o;(&Ih1IO|I8Q^Tv^lt}nw0}Qv
zJ~jH^0FLeYE8rOCXMm%fp94of&jj$XeA7&c`yKsX0v!Ec4IJxT3mpCI2G0A#ro9gV
z=QquUKLH%=zXBZF^-cgUk$o`Tt_8r+{*3{AHE`^g7;tRwX5gsb4IK6N0Y`tH0M3sf
zCO$s~j{S8CINBM*4=0p34p{FL;HW<hIQqW;INJGK0AC9n?Kc8P`*#CJ`(Fi)b{+tZ
zc76mL$L$H=IDUQ&9OL|7z%kBMvQNwLMElEuqn{grW4(U@9PRIxeQ&mp?RpS6#z)N1
z`#j729b=~`@v{jh!(Ze=lz0wuGJGLBMJeq5&GE&;uTgxj*soB0ndr|^`~|7EO7VXe
zzCiKG+-ORRyo2xOMyWTV_%z|wioYs$mMgwm^liltiT+B(9~J#t#s60PzeDk6iNhMj
zHw#~<cuM$s#XE&JD85a2lj8RYPb%IcyiM`6a7Xby!nY`XwZvho;>(5aRJ=~?bSpkZ
z_-@5_2>+Vmj|<<c_;-ZwQ~dkFA5{DY!XH-rDdCSQZk~G|Q~W2QzhCjg!oR2ZOTwR2
z+&n)YQ2g&i|DfV0gg>YF&xL0c|3~3R6#u30KE>Y@eq8Zi3GY{YSoqHrKP7xX@ppy4
zq4*i$gNmOO{+8nJ3m;OvNS=pJDn3T|X~oA1|E=Pe2_I2>qVV4-enXi6+5b1|>Ze4%
zRPi;UU#9pp(Kp{37&|kBPf+@^g-=%edg1QBp(NLgoq59De^3d0q42P>vsm~wiZ2yj
zq4+Z4a}=);ZoZE&{@fzmyiYZJmGDK%&TYaYiq{FRR{W2IoA;o`{$0Xtr5_V+-ZvTj
zxN!6RhT#d}cPKl}!q+IiS@=4|Q^MCP-YL96@omDJ6u(b+Qt=+)=KB)ke_FVs^!Eto
z_tl(?{?~<XRlHNi^G?Md68&z)9})eqYdvRQvR1X?w@SW2ar0fmZpF=a33?qi-zDgE
z%zRIv*9Y^xf}VHgy8%6J&36NOJecnWbezq5{RdTi%=ZKb6*u1#3@C2CCm2!Od>>HG
z9Z1Raqxn7{qPY3~V4dRTJCdD>o9{>-Ror}!l2P1zzcQ$}`Od?t?C5NEVjJk_w0p-U
zbJiYD#ws2DSfR2Z=ESVZ4ILd;rAymeJ!0O7SGKe|@k;u@?Rxk70n5v8Y)MtNwYRp#
z+nr7+7;lO;w#S;|UUWYC-!PfrE|A+o-(a<z4axnx5lDBLti^kOrSz-ziFeW`AN&l;
z^T>F@Tvn!$f1f{7xV(1s3e(>Tei>9C>H6o84%_^&<v&AZ*`{<aoq5UBzgtzvZN)T?
zGKJc|{{~O%pfs4<&(CSP{rtZn;3}%<hv`XvxkYKJckurjcg%4GNzA#gL?_3kJTgAl
zx?dv3j}W^3{Zd~0W&CGboLcF}Hg$Q^!6Qnb%YT{57K-2c2ni@nkn$WqUYbq$au!l5
zSU2$ze%VB+U&`}#EZ3vU^KF?PJA|x0-rS+|o(h=Cy6=Dsm2cyYrNrNzVbbOQ2RRN{
A`2YX_

literal 0
HcmV?d00001

diff --git a/main.c b/main.c
new file mode 100644
index 0000000..50c765e
--- /dev/null
+++ b/main.c
@@ -0,0 +1,3 @@
+#include <stdio.h>
+
+int main(void) { printf("hello world\n"); }
diff --git a/main.o b/main.o
new file mode 100644
index 0000000000000000000000000000000000000000..09c8eea649fb1e473545a06625decf9d9916c024
GIT binary patch
literal 1496
zcmbtU&ubG=5S~qHtJu_7Jc#wMCsEKxvR>4KM1wX5@lXheAhJ!jM$Kl!?kl!l6c1t#
zLXZ9_9t98jXLu>}sCS{xmz`-}9_vL1-kX_kerD!v-rRd|zZL|f6wqxt))XarR6CYC
zQ?Wx!)S!NEcfa@X1d!hDw*&CcxSo6+CZkanzRL2^2GMG_dn>%W`mlc`Y)2+C?J#OZ
z*IQAm4QHk~J|Q1uVmGQ$@CBGsAiDN;P7J~8H43(y!OG&o$vrk+WE=-{0oR?S=KET=
zG2dqg=zk&PougleRpxr-M2PCsZf7G<W7+Ya_P|(!Pjl9_)YAC**bE4aCR?@;p9SF<
zd!5hk!;;Pjj@e*Viid*3-&qxrDRxpDuQRuK$%iWC$tX59*|uahVjGiLFA6ewRw{!m
zO_MR(#+gkF@8nux<H1YOpN+T7B+n*EZg)5anUdkt%{)#M>E!=d$l=(@yqBgUy3SS2
z`Yu#oVF5GhC?NckIJQJT%^Z-vjq`$E5*)L4>9MOgvS0ry+mQ2L<MCY}=gcly*ZPYr
zyX4ou$wpxMJJokn1pP)7*LdZ3*`TuefWLDUNA`W!*oHUk_y0j+{JwPln(_q;$mz#V
z|6CZqp^n1+c)Y@@{ePE6b<f!UDLxvncvWqb`iYBauVjQhppGApoc`_+@>c3ELvcvp
TBjhYgRq;Q>(H?o0f*=0}`D|ws

literal 0
HcmV?d00001

diff --git a/wacc b/wacc
new file mode 100755
index 0000000000000000000000000000000000000000..8ad967f06e9a5dfc69e2b81b0f8a59ac7396d271
GIT binary patch
literal 20744
zcmeHP4Rlo1oxd~TBU)gB0?i7-fFc292p_UgL!AJD7X*n)Dpu)pNG4>;<b%l@4X!{u
zf!1l36&Jh9w%B7=+pe{G@MBlRbGn0A2(HyAZq2$@BVwIwMDaU*l-b|^-ur*^=4E0%
z-Q%7;XXl>0{O|ws{_p?(-+lMqnR(kPRxa~;Jc3Js_@*GNtw>RVnsIBTt^fqZ0x=T*
zCyH~$FyKQZP4R;YfU8QkHyajedI2Em6;mY#oS?{pA$v%W^ad+yhbs<4q5DC4Ly4tv
zH%xq8=`m!!-Cn8U3m1G^8Wn<}Q;%ZPwMgl8t;&Y=Ixfu`vL2zN*Q51%w4M!hAbK?9
zcv4L0TA<_UhC%SC1m%Ar+<L8A&kdJqd4|*mm8;&cYX6+}s<hso*~*R^zM#m0A-8u0
z^e8T0w(u}tsoNWD97=Wk8S1c#S<%S)`SWH)YiC9yjq%o*tqbPQoIfwn(iE5@T_C?G
z6=?XEUtTS|Z6ZlD*7pdH#LobYidW;zC)qK$DD0&FA6s|F_RRd@{g1BreBCSY-o4k}
z*>Ek%P(MhAWT+60E-u95i)mj5UId}DatKno<)Z%pbbk(cYCD%a-A=jaG={n8KL_29
z%U%8%1izaI{F}I@<e*OkEth@K9JgA8X|`CQnvG^n{YJAc6p4x!D;5nmf?i{7ZVsF4
z&1h2%FbsYTiN-9mArz7P){t2jX$(apH-$;7v8JI}kQk-Je6f6G<>DpgoWNYWHqWlj
z30!Q~=gt#m<(gGyZ8#R*5NWZ(u{EofM4KAJYeMUzVYIxVp{Y@~Y%0;5g6O3ex#PiA
zfP6r<0a7k{fKjG!{+}I*jHE0zHEoQ<hlq&A<L5+>q6MNw<B#0_cNikC*an;m&s#iS
zG>=yFZaptC-LL7TRf^Aa#*?cRoyMPXhD)b|uBRZ$>T=NalrHJr4m!6%j2;J_?>VWU
z{UICrR+r>L2i<u;6*=g7YM1iG4m$OLi{C*%lZknlk3c>G`3U4AkdHt<0{IC1ACAEL
zzKNe2?Qazt9YYUZDul5kX?fFKM*EY6hosl(i=P5HJ@sk)_e~0-MtD8(dVA6+Q=cH5
zmUO*c5<fsVEwy@+5`TzrTH5vQllU(QrzKbKUBIdR*(WO#&wa;895>oeoT^$=F*`Z?
zsIha=OOQ#A9S`vj>H@w=+kwKtor`V(#n?IYCISolt+8<ZG`0ie`WfjS-=sE@JES4x
zuaNQ=uOKk}w2?Sv9DMsy<6wV*;W=zPciI{Q1HaV<3e!DxzDY|n`s82RqLI)Q@wwGT
z`=Vdc&cjH&VU0987QGE5J$4WNr)tod!$VJ?>RERv<L{xmOr7FK_Ifu!wi-6ji?)em
z?MUj8)9Lhna(vw($w_SKHWKkJBT?OHbX0WL`QAzTMhoBQU=g84M>SYn?KBcqvVJ63
zOanm@M}iZmx=We63PW6CXq&Z0$B?NdB$ud2%}zoZwvMD;!glo5iZ>a(59s!!HH-1S
zv&k@db<jv0BWh)$>j134%;A(D(!Ku#BsCr#F*=0d`*ro3hUa<1)8%_q_#RD86@DQw
zL>Mmi|98~v?NI95)VAf#(yin1f8jQ_z<BhduPSxukAvAoF6~Ihhe6qlyOozC5&O<|
zHTeuQKuXmb7pg#5LsM&{dGc&s|4}&vUnXY1K~VZeP%x+~kIE3KdKC5cQyxTcW~xxy
zE@rV!B<A~d((vG~J1aWzM_jI6Dx;b0>b;*+B;2kp!0;jw;>m%-n<VEh#I6_vP8o$x
zR!G_~c3)!sB%wL?qt5PE%J#^8DfSSF4R9ZOF$@B^FNGRd-?zP;Qbdz)0J$s>Z;>&R
zg6(8Ya~H4@V)nvk)JeP1MI`nGjp8Q39YN{Y5r^I9Dii$&Xd6g9-;S+m-+5>xmk{mc
zNXUc`M6z-sD19I`XHNX7KtEAL7PA9=C%Hg*0^g3LZc}Z^`cl+Ypc_*?pJw&BlEen|
zS!MepsfV+LC*%}Xqw;-j_+z+MX8N|bVE#d%5HOt!J4X&VN5!EGcN>znWRP%;(BUeD
zrQY}C$Yz;I{)IC0Ay{8v21gPy>b*Xgxo@DEt=h~3%FNV3ycwm<{3FctZE*D{sBL`r
zi)}zvy7C>eF<6$+NdS%9LI}Z^tSmX_6L~v2vILWDDelG;J!%q|<leK>A+f55)Qyg+
zLclI#`V+Vv`%&#7>&bptT3FF<4VO=XzG+I9ruHsl=Lj!`OUoWM63?bKL3~HjcSlmq
zS7_C*T8;NO=YW1W#mfdhM!=9z?WxJ_{nz=vpTy*tNE$oG>_GSEk$QHq5FJCj#vWtm
z*x{&S@=j}qt6@OS*ZZN=`w#f1oU`c<BQbk#8A$&XV%Hn7>8pAUAa#V1c!qlXA`-NB
zrIU#?X66B6&T=v_2{7|cVxHw>VlHE58!<mbCMzG&CLOivHfxC4?PQM4FqaYYaVK+J
zhB=*>KXEeYlvA4>LCjm6Oazdb@8I~Ux7Nu-ax(LIVlKCt@t*SixEaM`^a;R$^Q7F7
z)HE_bB}-_$Ep)yX@{-UW36V)gmgw^nWofDw`aLz*Z4220xQCRJHl38QHqpw{h>iif
zi<EzyB{azvD$zoJ1);vp86W(%#B?oj4M|*`k(g{t%+L~lNfH-lB&OIB7ix*IBtegM
z+)j2Uj^Ydsq<-h4ee;L%22Eui>wjtrPm>kb6#mlJq~#<<;WpIer0v`O3VEaF^*tb$
zwOUgczm@Q{z8$nm%FO<^I}9yjL)NC$@ejyN`-yiMi4B<jF-FeE>;=@q_1o^@7RM1@
zxAhLjhY=p!ww>{h(6O>*zQ1Xf4}hExL_}4N^yLucbda6?5eT}|-*a^OZZf&vn#fJ;
zCVX+cF4N(=Kw)k*8?pRMT2Bh4)^m(sN%(B*AaKm71D@)Lfb{PHJl+SLulcE-fDr6t
z&DY<3e~|eaOWSzYz?oAn?M|XuWJC|9Yor@J+>fL>m2p|$g1Ua*VF`kC?7;L-Pgu1S
zq3sW;d;&AQZ7O<F?+JBB%lblPgOXn2mB7oUS@iJxBAY*h%|3gXK36%FO963}PFU0z
z*F94Go(xL2{U|BTwOde+66xH_$P;%!9#w`VKZ-g6GH(#)@vxA-q+q7^Zbv{Kbks{=
zL#>U}BM<?+7^Jc(aY`21%uv;g9ka2LKWNOj*-bQe*fC2}UvdYTV-{2*S@X)|cbze#
z?Lx79{?d#DSAPJNvg>?1UgAj`v>z%nlD`6V)w{`PT#~LPmD2cV#_NFh{>q_0j&<y1
zwbYv=^|rRKo{#W_+iDn}2wdKeQo0BjbAE$6Mc>pxw3AwQiYFl{dKm1%CZT=3qa2>y
zoH5j?hEN*V0Wzk<G2C99a7>B!IAq#D%Xk+9#?sSJ*WUdM3aNj6C(FAM5*=iU+{ZQw
zAXIk!R>~mh(fe4BV2a$u`0IoRw;GHeBOFs?6jNm19H!n0sv0amla7MacNSxh6E<X5
zpJx{=^L7C#5#;+QQT_BFbIa|>O82c4g*lkUZA>f1Evb&`r)fIDwuVycA<}T&!Mopf
zW}~a+MCZ~(#gn&IbPnRes2nczsz&5(_7l`q_ZOjENxBcD1r?p~i<t13k{`t7G^W5l
zdPq3<Pdd8vD){a$B~QA#RLa2|q#Mi0h-;Rf;^@Z5;M4lIf04Bi|F(tO`)63^wD-@7
zU#mRB(?+dwcOc#RA}(SH^1W{jh%x|2mB;AMfa(5R%5IF)nGliBs9Zu9XrVXMA~tJk
zIsBHZ=YBb}BnDmCmr+Z!!R(=S1Ijg7e;wx4(9ta*NvA+6J5x@g5~qED5}Cjvzf~f(
z#g~DDhi96-)VfEFPL|)Jl;4h}R!OcQbDTQ0!|;)c6Ns$ny`3VWqf48DvRQF^V!u{7
zAR}Ldy7Kp1EPgJD&xkK;hpE0GQ->>RDdXcDM*a;=;sHf7lQjCDz|r84_J$K4ru_jl
zuKyTy*{E;FT1*Y?TTTee&i!Yk=kCKXv?l0qtN^M54xz#bm7Ii}OVwxoOO1Qh6jGWi
zgpNn?6|$M^waG=w^IUlc4!k;&YLGr>FO@IX?ekKZHnAP6aBV6ixU{3Zm|(}|3E0~%
zO&rD%pz#>&2t*{ka`HjrjCYO1Q;AQEgRl8<CnY{o1V?xD86;*yBhk5%&Jv%(9lH<f
zs{Jz3YG(}mcgFO?pmbyAql3;>=nBL-AeJaEG!j>UhPfos42LSZ?L*UkV7TP=8W5+Y
z3!m`qPP+M|Ozc8Bp8OX+bERYO#1>@&0lF7`+MbM8OIhHL0mp4alURR8uy|(`<w<{{
zs+fR2Z|$RJH@FjQF5Ob9DNVv*Z6O{LM-R!fU`*77nbUR(WxnJikdHt<0{IB!Ban|k
zJ_28D1U&dwWPLaqZSvpP6pPl1NSz2rTf*YT`Ut*{x;_>TZ4~pdDh#C3>Aiq-z0<4U
zIM9~is=@UTX!W>8<JyVq1JGUsJpE=ykM(oG0Aw%2wHEfr;JQh-l}q-kq8)(GWcx)8
zzp8cyv)iWIy%W$gzTlD<F!b~}!L6^P(}h^JrvOg@f9=(Dx)k_lfK`AideZ4;z^$*P
z({}()KaTGb0RHXk>GaEh``<{X>C3NyKcv%sz-q)f2w2~jPS*l%##UrI;QiRq-2-?K
z$1I(Im*6lc1vm-^U4__E7UGbw1Taa5g@8kFVjTr+1N>{iV}SbrOL5@d1y}`m3a|;V
z2-|Qf^g#?2&rMefPiv89{D|R&yWk_y>9dMczfY%WXDpTur_YJR`MBocY6bmzKryOl
z*{I?bzOUU_*d{JL=aLz7&!0kM(!CDXy@(NgdLqh46@AaUWaO}FGys(NH{-e+{MCRq
z-@8Hz_(9r>>v{0!!5^Dn(Oyt6!(+=N!8(q(-v{WF@%~h`;|KW!t_a2?;<jUE?9g~V
zfbqHj@palMnBbL$$Y0vT?ZX(}fVwT?-DLAuf<Np;Iz0_Bw)q893P`{YQWX4=xc|;}
zw{b?M4T}Be$hXme85<*{qvXRr&`%;?vSLy&OY*6WF7Q3bqcQF_&djv&0c74qj@<-#
zyA5yL?g!~!hTJ=r#ec@;&jbH7_@8F+KeYL4!0*QK*ZwU2!;<d@%>us}Ila``M;g~}
zsPUkF?t#oM<onH8Hg2?S(8r!{fq#{gU*2BeT_r_ie$gSxc-$-NoHE|Ewx6GazZQJI
zlYebSe*(sl`1FaI9j9++_;ko~HTag3?`={7M9Y_a1o9EcM<5@8d<60l_<tDz{(T<*
z9*>qhROmN>ROkzQvdGmn)`uFsd77%weuE1C?vK7?M1|JSROH$kkbnP2YbPqq|L}CW
ziSQ(?Nm1}QrYtGF{>P`Wvh-*^eZWrTSp@{Xup$e6d5Q{sH_KVHnn=k-eC9WOty+lp
z7x;`@7X7ns(W4t?x?kh$cT&sa>l3nY`}hi|><@@i^t8sibjR?SfaG(Wu|$;ke$B_1
z10~LWYxDo>fPX*kZg{@VgJl|iOT#)1Z_tqS`1hR4mn`{)zXZQZp6;JLCom^4+drpt
z&fL;DrL$QwH>5ZX5$~qmTncV3I?3gtlUp8Shr3@Ye@6@cT{-Dfq2D`u#MkY-kwpAk
zjElZj=q@G*XNggwLN3O!KgHUe%8j^k$#;P6$K@{fqr-ktEJ~`fIllm!%MR^fsNJ=+
z@kNn)7QlbUMf572&~i@*T1wMT>Kjw;^*|enc8k#N0#~~uKqor~>Fbgxa*qmlzNTL@
zS(1g^tD#!1=_$D>7ea?atR}kGCwSgaT9{{~JYyMHKM1{D+sCUUWRd$&)OKt7?$L_A
zS^;sFrgv(8{F;6r=+s|#oar2d`dh5!<^ByiM>Kt-rprAW=*K{3o7%Jl$3Y+MEf$>r
z%zKCE^lR%<MbXooI1M_rJ5I-0o)<ub@`&h%^*GACJLngIUWC)0pliHlYx%uXm3_HC
zMfE{#zYR@O(cKW0+KzkNtF@iYI-Wd_e_PXM=!sUIN5CHaf`|M(Hd&e%#}p8^Y5H+(
zN1h9S_ajaJ`4lDisg{3G(?`>HNl{q-5a<+7x1Y~y`Mb_j@^n8?ISIO7*0TQ%$HY1%
zn<TL*pr7T%(@w{SMd<u0*L@e1^ig8Ceh$h#HYw5X{{uB58g3280L`V>TwcDaatVH_
zkIB!hFwA9FmanQXjipx#bNR~Ei_2G<tCuais$z|~rhM_r3jB!Q{WgK1{jz|0%B<P4
zG13evybT}}#k&bYF@D2<ElTeY_@WmF(Ay2Ngr&dAa6>$5Mer7juvyd8&=794xYg!R
zBVKP{)zpVuG^ru9F>FQ}Ewet{YBt5p^?2h!Y_l-KwIM6ymI1#m+7x1QQnw}2xFL#$
z&<E3M+K5*xC`W4Iu^6>X?@);7w=QJ)>wYtX&EyzK^D;KtB95l5ur^<dHz**`<fVFf
zf~Ge&wM48)6MLaNa=&E3tZivB>qCvT^a6&;)i6*SX*A<4;aY7)4i65*t#C_osD|5A
z{k1|?q(*nu3^%fh4&)7ZUqr1MQPW)C(xRP{@03v8P=Z-%I)(^uZBra?g%}vk#&BzP
z)T5!6`mA_s=VBNR#0Bq|Fe@%!YMRatsb;eBLS|Ub_f6mh8IBiV*n=a}5+jO%b-qEv
z=FjB@t#C8WpIbIJSfTZRR!qTqt|8~bv1SoyY_h_E4UO?YbF8U39J4k%NbBPfypAPO
zt4ZaHD`#4v4MK|7BLE^$ySWifC}_nL=Z0{sg)%^jX~YCC7LJBULD!n2mI%n61T2bf
zKqhJ+)+94O5Uw}tVxfkxSzilX#*~H`ip4^3lr*>w!=Z*q4O(r2E&L0}29z-*f(Y=v
z$P?555Yjpwj|4jAm!%l<85M@SPFGYV%XNb1;i9!M>o3sy41?e~3$L4*HXjwIeyi4J
zsFyP=jx}9&sdVY@)%pzm+2RBAuLl1kthL#H-hVLU{twf3-2R6^r@aU3^ZtY(o!3*L
zK2nwSd7lsgja+7Z-tRDc7CdLs=4{d?)Mzik`n-Q&NIyfN!v3=y!>!=a-h^@9pD^TQ
zh1-8=6#sVOqA_88-XAecf=7khclZDA!6W^}B!tqV1sS#~vec)gk6ZtzpixZNzWv<R
z&u`v`YBK}If3Hj5uk{#S&x#sqw%yDxT>5QVfZ=C604{wtd%sJc*ToEZpUv{_{C`;M
zbNqQd$#9P=VchzUyYzYg!|(-eSVOn|QI~%693{x`I(<K~86H2zX?;jP$73-*Kj8On
zx#byW_$qXL4t+jf=w1XO3d<=hgEPGk49XpDpZA6Kd(?FNDF3Oj9_PUappgjc^ZSaD
zmy)y)B?{R8S)bu2;5ha9d?KawgSMusupUD%l%4v#k15fL>?fOHJsXEI(b#`pS1-`|
zZh30USw`yiOPxg2S>JvCvAz@9x$Cg8HmHzJop3Y{(-^QnJb%);3;V7#)PH}4f|t3N
X+%C(~cElwjSsM){G0vsnLdAarVN?(d

literal 0
HcmV?d00001