diff --git a/LXC_Tests b/LXC_Tests
new file mode 100755
index 0000000..a6b7e28
Binary files /dev/null and b/LXC_Tests differ
diff --git a/PashaBibko-UTIL-Example b/PashaBibko-UTIL-Example
index 6b8680c..b976101 100755
Binary files a/PashaBibko-UTIL-Example and b/PashaBibko-UTIL-Example differ
diff --git a/external/util b/external/util
index d4b9996..fc5381b 160000
--- a/external/util
+++ b/external/util
@@ -1 +1 @@
-Subproject commit d4b999676de284972fed3f5a07a33c166ccf8602
+Subproject commit fc5381b3ae14a2931c97e14658164ba596f8667b
diff --git a/lxc b/lxc
new file mode 100755
index 0000000..0bfe61b
Binary files /dev/null and b/lxc differ
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 9e59e18..b8571ec 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -4,8 +4,8 @@ add_executable(LXC_Tests
 )
 
 # Creates the shared precompiled header #
-target_include_directories(LXC_Tests PRIVATE ${CMAKE_SOURCE_DIR}/common)
-target_precompile_headers(LXC_Tests PRIVATE ${CMAKE_SOURCE_DIR}/common/LXC.h)
+target_include_directories(LXC_Tests PRIVATE ${CMAKE_SOURCE_DIR}/external/util)
+target_precompile_headers(LXC_Tests PRIVATE ${CMAKE_SOURCE_DIR}/external/util/Util.h)
 
 # Includes headers for modules to test #
 target_include_directories(LXC_Tests PRIVATE
diff --git a/tests/src/LexerTests.cpp b/tests/src/LexerTests.cpp
index 479afe6..bff9d05 100644
--- a/tests/src/LexerTests.cpp
+++ b/tests/src/LexerTests.cpp
@@ -56,72 +56,72 @@ namespace PashaBibko::LXC::Lexer
     TEST(LexerTests, EmptyInput)
     {
         Util::ReturnVal result = TokenizeFile("");
-        ASSERT_TRUE(result.Suceeded());
+        ASSERT_TRUE(result.Success());
         EXPECT_TRUE(result.Result().empty());
     }
 
     TEST(LexerTests, SingleIdentifier)
     {
         Util::ReturnVal result = TokenizeFile("hello");
-        ASSERT_TRUE(result.Suceeded());
-        Internal::ExpectTokens(result, { Token::Identifier });
+        ASSERT_TRUE(result.Success());
+        Internal::ExpectTokens(result.Result(), { Token::Identifier });
     }
 
     TEST(LexerTests, SingleNumber)
     {
         Util::ReturnVal result = TokenizeFile("12345");
-        ASSERT_TRUE(result.Suceeded());
-        Internal::ExpectTokens(result, { Token::NumLiteral });
+        ASSERT_TRUE(result.Success());
+        Internal::ExpectTokens(result.Result(), { Token::NumLiteral });
     }
 
     TEST(LexerTests, SingleStringLiteral)
     {
         Util::ReturnVal result = TokenizeFile("\"string literal\"");
-        ASSERT_TRUE(result.Suceeded());
-        Internal::ExpectTokens(result, { Token::StringLiteral });
+        ASSERT_TRUE(result.Success());
+        Internal::ExpectTokens(result.Result(), { Token::StringLiteral });
     }
 
     TEST(LexerTests, MultipleSymbolsAndOperators)
     {
         Util::ReturnVal result = TokenizeFile("+ = (");
-        ASSERT_TRUE(result.Suceeded());
-        Internal::ExpectTokens(result, { Token::Add, Token::Assign, Token::OpenParen });
+        ASSERT_TRUE(result.Success());
+        Internal::ExpectTokens(result.Result(), { Token::Add, Token::Assign, Token::OpenParen });
     }
 
     TEST(LexerTests, WhileTrueTokenTest)
     {
         Util::ReturnVal result = TokenizeFile("while (true)");
-        ASSERT_TRUE(result.Suceeded());
-        Internal::ExpectTokens(result, { Token::While, Token::OpenParen, Token::Identifier, Token::CloseParen });
+        ASSERT_TRUE(result.Success());
+        Internal::ExpectTokens(result.Result(), { Token::While, Token::OpenParen, Token::Identifier, Token::CloseParen });
     }
 
     TEST(LexerTests, UnterminatedString)
     {
         Util::ReturnVal result = TokenizeFile("\"This is supposed to be unterminated");
-        ASSERT_FALSE(result.Suceeded());
+        ASSERT_FALSE(result.Success());
         EXPECT_EQ(result.Error().reason, LexerError::UnterminatedStringLiteral);
     }
 
     TEST(LexerTests, InvalidCharacter)
     {
         Util::ReturnVal result = TokenizeFile("^^^");
-        ASSERT_FALSE(result.Suceeded());
+        ASSERT_FALSE(result.Success());
         EXPECT_EQ(result.Error().reason, LexerError::InvalidCharacter);
     }
 
     TEST(LexerTests, InvalidOperand)
     {
         Util::ReturnVal result = TokenizeFile("+/*");
-        ASSERT_FALSE(result.Suceeded());
+        ASSERT_FALSE(result.Success());
         EXPECT_EQ(result.Error().reason, LexerError::UnknownSymbolOrOperand);
     }
 
     TEST(LexerTests, ExampleFile_LawsOfMath)
     {
         Util::ReturnVal fileContents = Util::ReadFile("examples/LawsOfMath.lx");
-        ASSERT_TRUE(fileContents.Suceeded());
-        Util::ReturnVal tokens = TokenizeFile(fileContents);
-        Internal::ExpectTokens(tokens,
+        ASSERT_TRUE(fileContents.Success());
+        Util::ReturnVal tokens = TokenizeFile(fileContents.Result());
+        Internal::ExpectTokens(tokens.Result(),
         {
             Token::FunctionDef,     // func
             Token::OpenCrocodile,   // <
@@ -181,9 +181,9 @@ namespace PashaBibko::LXC::Lexer
     TEST(LexerTests, ExampleFile_Fib)
     {
         Util::ReturnVal fileContents = Util::ReadFile("examples/Fib.lx");
-        ASSERT_TRUE(fileContents.Suceeded());
-        Util::ReturnVal tokens = TokenizeFile(fileContents);
-        Internal::ExpectTokens(tokens,
+        ASSERT_TRUE(fileContents.Success());
+        Util::ReturnVal tokens = TokenizeFile(fileContents.Result());
+        Internal::ExpectTokens(tokens.Result(),
         {
             Token::FunctionDef,     // func
             Token::OpenCrocodile,   // <