diff --git a/.github/workflows/linux-workflow.yaml b/.github/workflows/linux-workflow.yaml
new file mode 100644
index 0000000000..c72db11797
--- /dev/null
+++ b/.github/workflows/linux-workflow.yaml
@@ -0,0 +1,26 @@
+name: Linux Workflow
+on: [push]
+
+jobs:
+  build:
+    name: Build and Test Project (Linux)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v2
+      - name: Get Package Dependencies
+        run: sudo apt install gcc make cmake build-essential g++ nasm clang-format
+      - name: Initialize Submodules
+        run: git submodule update --init --recursive
+      - name: Build Project with CMake
+        run: |
+          mkdir build
+          cd build
+          cmake ..
+          make -j
+      - name: Test Project with gTest
+        run: ./test.sh
+      - name: Check Clang-Formatting
+        run: |
+          chmod +x ./third-party/run-clang-format/run-clang-format.py
+          ./third-party/run-clang-format/run-clang-format.py -r common decompiler game goalc test --color always
diff --git a/.gitmodules b/.gitmodules
index 3f127b847c..522084739f 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,3 @@
 [submodule "third-party/googletest"]
 	path = third-party/googletest
-	url = https://github.com/google/googletest.git
+	url = https://github.com/google/googletest.git
\ No newline at end of file
diff --git a/README.md b/README.md
index 0fdd8465f2..1a6a7ef923 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,5 @@
 # Jak Project
+![Linux Workflow](https://github.com/water111/jak-project/workflows/Linux%20Workflow/badge.svg?branch=master)
 
 ## Table of Contents
 
diff --git a/common/goal_constants.h b/common/goal_constants.h
index bf9239e322..88d6896e2f 100644
--- a/common/goal_constants.h
+++ b/common/goal_constants.h
@@ -1,16 +1,24 @@
 #ifndef JAK_GOAL_CONSTANTS_H
 #define JAK_GOAL_CONSTANTS_H
 
+#include "common_types.h"
+
+constexpr s32 BINTEGER_OFFSET = 0;
+constexpr s32 PAIR_OFFSET = 2;
 constexpr int POINTER_SIZE = 4;
 constexpr int BASIC_OFFSET = 4;
 constexpr int STRUCTURE_ALIGNMENT = 16;
 
-enum class RegKind {
-  GPR_64,
-  FLOAT,
-  INT_128,
-  FLOAT_4X,
-  INVALID
-};
+enum class RegKind { GPR_64, FLOAT, INT_128, FLOAT_4X, INVALID };
+
+constexpr u32 GOAL_NEW_METHOD = 0;       // method ID of GOAL new
+constexpr u32 GOAL_DEL_METHOD = 1;       // method ID of GOAL delete
+constexpr u32 GOAL_PRINT_METHOD = 2;     // method ID of GOAL print
+constexpr u32 GOAL_INSPECT_METHOD = 3;   // method ID of GOAL inspect
+constexpr u32 GOAL_LENGTH_METHOD = 4;    // method ID of GOAL length
+constexpr u32 GOAL_ASIZE_METHOD = 5;     // method ID of GOAL size
+constexpr u32 GOAL_COPY_METHOD = 6;      // method ID of GOAL copy
+constexpr u32 GOAL_RELOC_METHOD = 7;     // method ID of GOAL relocate
+constexpr u32 GOAL_MEMUSAGE_METHOD = 8;  // method ID of GOAL mem-usage
 
 #endif  // JAK_GOAL_CONSTANTS_H
diff --git a/common/symbols.h b/common/symbols.h
index 750e430d87..a16cfcf543 100644
--- a/common/symbols.h
+++ b/common/symbols.h
@@ -6,75 +6,76 @@
 #ifndef JAK1_SYMBOLS_H
 #define JAK1_SYMBOLS_H
 
-constexpr int FIX_SYM_EMPTY_CAR  = -0xc;
+constexpr int FIX_SYM_EMPTY_CAR = -0xc;
 constexpr int FIX_SYM_EMPTY_PAIR = -0xa;
-constexpr int FIX_SYM_EMPTY_CDR  = -0x8;
-constexpr int FIX_SYM_FALSE               = 0x0;   // GOAL boolean #f (note that this is equal to the $s7 register)
-constexpr int FIX_SYM_TRUE                = 0x8;   // GOAL boolean #t
+constexpr int FIX_SYM_EMPTY_CDR = -0x8;
+constexpr int FIX_SYM_FALSE = 0x0;  // GOAL boolean #f (note that this is equal to the $s7 register)
+constexpr int FIX_SYM_TRUE = 0x8;   // GOAL boolean #t
 
 // types
-constexpr int FIX_SYM_FUNCTION_TYPE       = 0x10;  // GOAL type of function
-constexpr int FIX_SYM_BASIC_TYPE          = 0x18;  // GOAL structure type with type tag
-constexpr int FIX_SYM_STRING_TYPE         = 0x20;  // GOAL string type (gstring)
-constexpr int FIX_SYM_SYMBOL_TYPE         = 0x28;  // GOAL symbol type
-constexpr int FIX_SYM_TYPE_TYPE           = 0x30;  // GOAL type of type
-constexpr int FIX_SYM_OBJECT_TYPE         = 0x38;  // GOAL parent type of all types
-constexpr int FIX_SYM_LINK_BLOCK          = 0x40;  // GOAL type of link-block (used by linker, but seems to be unused by GOAL)
-constexpr int FIX_SYM_INTEGER_TYPE        = 0x48;  // GOAL integer parent type, assumes unboxed
-constexpr int FIX_SYM_SINTEGER_TYPE       = 0x50;  // GOAL signed integer parent type, assumes unboxed
-constexpr int FIX_SYM_UINTEGER_TYPE       = 0x58;  // GOAL unsinged integer parent type, assumes unboxed
-constexpr int FIX_SYM_BINTEGER_TYPE       = 0x60;  // GOAL "boxed integer" type
-constexpr int FIX_SYM_INT8_TYPE           = 0x68;  // GOAL 8-bit signed integer
-constexpr int FIX_SYM_INT16_TYPE          = 0x70;  // ...
-constexpr int FIX_SYM_INT32_TYPE          = 0x78;  // ...
-constexpr int FIX_SYM_INT64_TYPE          = 0x80;  // ...
-constexpr int FIX_SYM_INT128_TYPE         = 0x88;  // GOAL 128-bit integer type, behaves strangely
-constexpr int FIX_SYM_UINT8_TYPE          = 0x90;  // GOAL 8-bit unsigned integer
-constexpr int FIX_SYM_UINT16_TYPE         = 0x98;  // ...
-constexpr int FIX_SYM_UINT32_TYPE         = 0xA0;  // ...
-constexpr int FIX_SYM_UINT64_TYPE         = 0xA8;  // ...
-constexpr int FIX_SYM_UINT128_TYPE        = 0xB0;  // ...
-constexpr int FIX_SYM_FLOAT_TYPE          = 0xB8;  // GOAL 32-bit floating point type
-constexpr int FIX_SYM_PROCESS_TREE_TYPE   = 0xC0;  // GOAL process-tree type.  Used in the gkernel
-constexpr int FIX_SYM_PROCESS_TYPE        = 0xC8;  // GOAL process type
-constexpr int FIX_SYM_THREAD_TYPE         = 0xD0;  // GOAL thread type
-constexpr int FIX_SYM_STRUCTURE_TYPE      = 0xD8;  // GOAL structure type.  Any type with fields
-constexpr int FIX_SYM_PAIR_TYPE           = 0xE0;  // GOAL pair type
-constexpr int FIX_SYM_POINTER_TYPE        = 0xE8;  // GOAL pointer type (32-bit)
-constexpr int FIX_SYM_NUMBER_TYPE         = 0xF0;  // GOAL number type (parent of integer/float types)
-constexpr int FIX_SYM_ARRAY_TYPE          = 0xF8;  // GOAL array type
-constexpr int FIX_SYM_VU_FUNCTION_TYPE    = 0x100; // GOAL vu-function type
-constexpr int FIX_SYM_CONNECTABLE_TYPE    = 0x108; // GOAL connectable
-constexpr int FIX_SYM_STACK_FRAME_TYPE    = 0x110; // GOAL stack-frame
-constexpr int FIX_SYM_FILE_STREAM_TYPE    = 0x118; // GOAL file-stream
-constexpr int FIX_SYM_KHEAP               = 0x120; // GOAL kheap
+constexpr int FIX_SYM_FUNCTION_TYPE = 0x10;  // GOAL type of function
+constexpr int FIX_SYM_BASIC_TYPE = 0x18;     // GOAL structure type with type tag
+constexpr int FIX_SYM_STRING_TYPE = 0x20;    // GOAL string type (gstring)
+constexpr int FIX_SYM_SYMBOL_TYPE = 0x28;    // GOAL symbol type
+constexpr int FIX_SYM_TYPE_TYPE = 0x30;      // GOAL type of type
+constexpr int FIX_SYM_OBJECT_TYPE = 0x38;    // GOAL parent type of all types
+constexpr int FIX_SYM_LINK_BLOCK =
+    0x40;  // GOAL type of link-block (used by linker, but seems to be unused by GOAL)
+constexpr int FIX_SYM_INTEGER_TYPE = 0x48;   // GOAL integer parent type, assumes unboxed
+constexpr int FIX_SYM_SINTEGER_TYPE = 0x50;  // GOAL signed integer parent type, assumes unboxed
+constexpr int FIX_SYM_UINTEGER_TYPE = 0x58;  // GOAL unsinged integer parent type, assumes unboxed
+constexpr int FIX_SYM_BINTEGER_TYPE = 0x60;  // GOAL "boxed integer" type
+constexpr int FIX_SYM_INT8_TYPE = 0x68;      // GOAL 8-bit signed integer
+constexpr int FIX_SYM_INT16_TYPE = 0x70;     // ...
+constexpr int FIX_SYM_INT32_TYPE = 0x78;     // ...
+constexpr int FIX_SYM_INT64_TYPE = 0x80;     // ...
+constexpr int FIX_SYM_INT128_TYPE = 0x88;    // GOAL 128-bit integer type, behaves strangely
+constexpr int FIX_SYM_UINT8_TYPE = 0x90;     // GOAL 8-bit unsigned integer
+constexpr int FIX_SYM_UINT16_TYPE = 0x98;    // ...
+constexpr int FIX_SYM_UINT32_TYPE = 0xA0;    // ...
+constexpr int FIX_SYM_UINT64_TYPE = 0xA8;    // ...
+constexpr int FIX_SYM_UINT128_TYPE = 0xB0;   // ...
+constexpr int FIX_SYM_FLOAT_TYPE = 0xB8;     // GOAL 32-bit floating point type
+constexpr int FIX_SYM_PROCESS_TREE_TYPE = 0xC0;  // GOAL process-tree type.  Used in the gkernel
+constexpr int FIX_SYM_PROCESS_TYPE = 0xC8;       // GOAL process type
+constexpr int FIX_SYM_THREAD_TYPE = 0xD0;        // GOAL thread type
+constexpr int FIX_SYM_STRUCTURE_TYPE = 0xD8;     // GOAL structure type.  Any type with fields
+constexpr int FIX_SYM_PAIR_TYPE = 0xE0;          // GOAL pair type
+constexpr int FIX_SYM_POINTER_TYPE = 0xE8;       // GOAL pointer type (32-bit)
+constexpr int FIX_SYM_NUMBER_TYPE = 0xF0;        // GOAL number type (parent of integer/float types)
+constexpr int FIX_SYM_ARRAY_TYPE = 0xF8;         // GOAL array type
+constexpr int FIX_SYM_VU_FUNCTION_TYPE = 0x100;  // GOAL vu-function type
+constexpr int FIX_SYM_CONNECTABLE_TYPE = 0x108;  // GOAL connectable
+constexpr int FIX_SYM_STACK_FRAME_TYPE = 0x110;  // GOAL stack-frame
+constexpr int FIX_SYM_FILE_STREAM_TYPE = 0x118;  // GOAL file-stream
+constexpr int FIX_SYM_KHEAP = 0x120;             // GOAL kheap
 
 // GOAL functions
-constexpr int FIX_SYM_NOTHING_FUNC        = 0x128; // GOAL nothing-func (does nothing)
-constexpr int FIX_SYM_DEL_BASIC_FUNC      = 0x130; // GOAL delete-basic function
+constexpr int FIX_SYM_NOTHING_FUNC = 0x128;    // GOAL nothing-func (does nothing)
+constexpr int FIX_SYM_DEL_BASIC_FUNC = 0x130;  // GOAL delete-basic function
 
 // GOAL allocation symbols (?)
-constexpr int FIX_SYM_STATIC              = 0x138; // GOAL 'static
-constexpr int FIX_SYM_GLOBAL_HEAP         = 0x140; // GOAL 'global
-constexpr int FIX_SYM_DEBUG_HEAP          = 0x148; // GOAL 'debug
-constexpr int FIX_SYM_LOADING_LEVEL       = 0x150; // ??
-constexpr int FIX_SYM_LOADING_PACKAGE     = 0x158; // ??
-constexpr int FIX_SYM_PROCESS_LEVEL_HEAP  = 0x160; // ??
-constexpr int FIX_SYM_STACK               = 0x168; // GOAL 'stack
-constexpr int FIX_SYM_SCRATCH             = 0x170; // GOAL 'scratch
+constexpr int FIX_SYM_STATIC = 0x138;              // GOAL 'static
+constexpr int FIX_SYM_GLOBAL_HEAP = 0x140;         // GOAL 'global
+constexpr int FIX_SYM_DEBUG_HEAP = 0x148;          // GOAL 'debug
+constexpr int FIX_SYM_LOADING_LEVEL = 0x150;       // ??
+constexpr int FIX_SYM_LOADING_PACKAGE = 0x158;     // ??
+constexpr int FIX_SYM_PROCESS_LEVEL_HEAP = 0x160;  // ??
+constexpr int FIX_SYM_STACK = 0x168;               // GOAL 'stack
+constexpr int FIX_SYM_SCRATCH = 0x170;             // GOAL 'scratch
 
 // GOAL random stuff
-constexpr int FIX_SYM_SCRATCH_TOP         = 0x178; // GOAL *scratch-top*
-constexpr int FIX_SYM_ZERO_FUNC           = 0x180; // GOAL zero-func (returns 0x0 in $v0 register)
-constexpr int FIX_SYM_ASIZE_OF_BASIC_FUNC = 0x188; // GOAL asize-of-basic function
-constexpr int FIX_SYM_COPY_BASIC_FUNC     = 0x190; // GOAL copy-basic function
-constexpr int FIX_SYM_LEVEL               = 0x198; // ??
-constexpr int FIX_SYM_ART_GROUP           = 0x1a0; // ??
-constexpr int FIX_SYM_TX_PAGE_DIR         = 0x1a8; // ??
-constexpr int FIX_SYM_TX_PAGE             = 0x1b0; // ??
-constexpr int FIX_SYM_SOUND               = 0x1b8; // ??
-constexpr int FIX_SYM_DGO                 = 0x1c0; // ??
-constexpr int FIX_SYM_TOP_LEVEL           = 0x1c8; // ??
-constexpr int FIX_FIXED_SYM_END_OFFSET    = 0x1d0;
+constexpr int FIX_SYM_SCRATCH_TOP = 0x178;          // GOAL *scratch-top*
+constexpr int FIX_SYM_ZERO_FUNC = 0x180;            // GOAL zero-func (returns 0x0 in $v0 register)
+constexpr int FIX_SYM_ASIZE_OF_BASIC_FUNC = 0x188;  // GOAL asize-of-basic function
+constexpr int FIX_SYM_COPY_BASIC_FUNC = 0x190;      // GOAL copy-basic function
+constexpr int FIX_SYM_LEVEL = 0x198;                // ??
+constexpr int FIX_SYM_ART_GROUP = 0x1a0;            // ??
+constexpr int FIX_SYM_TX_PAGE_DIR = 0x1a8;          // ??
+constexpr int FIX_SYM_TX_PAGE = 0x1b0;              // ??
+constexpr int FIX_SYM_SOUND = 0x1b8;                // ??
+constexpr int FIX_SYM_DGO = 0x1c0;                  // ??
+constexpr int FIX_SYM_TOP_LEVEL = 0x1c8;            // ??
+constexpr int FIX_FIXED_SYM_END_OFFSET = 0x1d0;
 
 #endif  // JAK1_SYMBOLS_H
diff --git a/common/type_system/Type.cpp b/common/type_system/Type.cpp
index 3dd0fe1a80..0c68f48d86 100644
--- a/common/type_system/Type.cpp
+++ b/common/type_system/Type.cpp
@@ -108,6 +108,11 @@ std::string Type::get_name() const {
 }
 
 std::string Type::get_runtime_name() const {
+  if (!m_allow_in_runtime) {
+    fmt::print("[TypeSystem] Tried to use type {} as a runtime type, which is not allowed.\n",
+               get_name());
+    throw std::runtime_error("get_runtime_name");
+  }
   return m_runtime_name;
 }
 
@@ -137,7 +142,7 @@ bool Type::is_equal(const Type& other) const {
  * parents.
  */
 bool Type::has_parent() const {
-  return m_parent != "object" && !m_parent.empty();
+  return m_name != "object" && !m_parent.empty();
 }
 
 /*!
@@ -218,52 +223,53 @@ std::string Type::print_method_info() const {
 }
 
 /////////////
-// NoneType
+// NullType
 /////////////
 
-// Special Type representing nothing.
-// it's an error to try to do anything with None.
+// Special Type for both "none" and "_type_" types
+// it's an error to try to do anything with Null.
 
-NoneType::NoneType() : Type("", "none", false) {}
+NullType::NullType(std::string name) : Type("", std::move(name), false) {}
 
-bool NoneType::is_reference() const {
-  throw std::runtime_error("is_reference called on NoneType");
+bool NullType::is_reference() const {
+  throw std::runtime_error("is_reference called on NullType");
 }
 
-int NoneType::get_load_size() const {
-  throw std::runtime_error("get_load_size called on NoneType");
+int NullType::get_load_size() const {
+  throw std::runtime_error("get_load_size called on NullType");
 }
 
-bool NoneType::get_load_signed() const {
-  throw std::runtime_error("get_load_size called on NoneType");
+bool NullType::get_load_signed() const {
+  throw std::runtime_error("get_load_size called on NullType");
 }
 
-int NoneType::get_size_in_memory() const {
-  throw std::runtime_error("get_size_in_memory called on NoneType");
+int NullType::get_size_in_memory() const {
+  throw std::runtime_error("get_size_in_memory called on NullType");
 }
 
-RegKind NoneType::get_preferred_reg_kind() const {
-  throw std::runtime_error("get_preferred_reg_kind called on NoneType");
+RegKind NullType::get_preferred_reg_kind() const {
+  throw std::runtime_error("get_preferred_reg_kind called on NullType");
 }
 
-int NoneType::get_offset() const {
+int NullType::get_offset() const {
   throw std::runtime_error("get_offset called on NoneType");
 }
 
-int NoneType::get_in_memory_alignment() const {
-  throw std::runtime_error("get_in_memory_alignment called on NoneType");
+int NullType::get_in_memory_alignment() const {
+  throw std::runtime_error("get_in_memory_alignment called on NullType");
 }
 
-int NoneType::get_inline_array_alignment() const {
-  throw std::runtime_error("get_inline_array_alignment called on NoneType");
+int NullType::get_inline_array_alignment() const {
+  throw std::runtime_error("get_inline_array_alignment called on NullType");
 }
 
-std::string NoneType::print() const {
-  return "none";
+std::string NullType::print() const {
+  return m_name;
 }
 
-bool NoneType::operator==(const Type& other) const {
-  // there should be only one none type, so this is safe.
+bool NullType::operator==(const Type& other) const {
+  // any redefinition by the user should be invalid, so this will always return false unless
+  // you're calling it on the same object.
   return this == &other;
 }
 
@@ -484,7 +490,7 @@ void StructureType::override_size_in_memory(int size) {
 }
 
 int StructureType::get_offset() const {
-  return 0;
+  return m_offset;
 }
 
 int StructureType::get_in_memory_alignment() const {
diff --git a/common/type_system/Type.h b/common/type_system/Type.h
index 5ce8dd69d0..a8c3474a3e 100644
--- a/common/type_system/Type.h
+++ b/common/type_system/Type.h
@@ -68,6 +68,8 @@ class Type {
   const MethodInfo& add_new_method(const MethodInfo& info);
   std::string print_method_info() const;
 
+  void disallow_in_runtime() { m_allow_in_runtime = false; }
+
   virtual ~Type() = default;
 
  protected:
@@ -79,6 +81,7 @@ class Type {
 
   std::string m_parent;  // the parent type (is empty for none and object)
   std::string m_name;
+  bool m_allow_in_runtime = true;
   std::string m_runtime_name;
   bool m_is_boxed = false;  // does this have runtime type information?
 };
@@ -87,9 +90,9 @@ class Type {
  * Used only for "none" - this is a type that the compiler can use for "this has no value".
  * Attempting to do anything with a NoneType is an error.
  */
-class NoneType : public Type {
+class NullType : public Type {
  public:
-  NoneType();
+  NullType(std::string name);
   bool is_reference() const override;
   int get_load_size() const override;
   bool get_load_signed() const override;
@@ -100,7 +103,7 @@ class NoneType : public Type {
   int get_in_memory_alignment() const override;
   std::string print() const override;
   bool operator==(const Type& other) const override;
-  ~NoneType() = default;
+  ~NullType() = default;
 };
 
 /*!
@@ -217,10 +220,12 @@ class StructureType : public ReferenceType {
   int get_in_memory_alignment() const override;
   int get_inline_array_alignment() const override;
   bool lookup_field(const std::string& name, Field* out);
+  bool is_dynamic() const { return m_dynamic; }
   ~StructureType() = default;
 
  protected:
   friend class TypeSystem;
+  void override_offset(int offset) { m_offset = offset; }
   void override_size_in_memory(
       int size);  // only to be used for setting up weird types like "structure"
   void add_field(const Field& f, int new_size_in_mem) {
@@ -234,6 +239,7 @@ class StructureType : public ReferenceType {
   bool m_dynamic = false;
   int m_size_in_mem = 0;
   bool m_pack = false;
+  int m_offset = 0;
 };
 
 class BasicType : public StructureType {
diff --git a/common/type_system/TypeSpec.cpp b/common/type_system/TypeSpec.cpp
index f52cd558c3..c78def6cd8 100644
--- a/common/type_system/TypeSpec.cpp
+++ b/common/type_system/TypeSpec.cpp
@@ -34,4 +34,13 @@ bool TypeSpec::operator==(const TypeSpec& other) const {
   }
 
   return true;
+}
+
+TypeSpec TypeSpec::substitute_for_method_call(const std::string& method_type) const {
+  TypeSpec result;
+  result.m_type = (m_type == "_type_") ? method_type : m_type;
+  for (const auto& x : m_arguments) {
+    result.m_arguments.push_back(x.substitute_for_method_call(method_type));
+  }
+  return result;
 }
\ No newline at end of file
diff --git a/common/type_system/TypeSpec.h b/common/type_system/TypeSpec.h
index cb42ba788b..04a0431b08 100644
--- a/common/type_system/TypeSpec.h
+++ b/common/type_system/TypeSpec.h
@@ -33,12 +33,18 @@ class TypeSpec {
   void add_arg(const TypeSpec& ts) { m_arguments.push_back(ts); }
 
   const std::string base_type() const { return m_type; }
+
+  bool has_single_arg() const { return m_arguments.size() == 1; }
+
   const TypeSpec& get_single_arg() const {
     assert(m_arguments.size() == 1);
     return m_arguments.front();
   }
 
+  TypeSpec substitute_for_method_call(const std::string& method_type) const;
+
  private:
+  friend class TypeSystem;
   std::string m_type;
   std::vector<TypeSpec> m_arguments;
 };
diff --git a/common/type_system/TypeSystem.cpp b/common/type_system/TypeSystem.cpp
index 7922eb90d1..3b61135bf5 100644
--- a/common/type_system/TypeSystem.cpp
+++ b/common/type_system/TypeSystem.cpp
@@ -6,8 +6,9 @@
 #include <stdexcept>
 
 TypeSystem::TypeSystem() {
-  // the "none" type is included by default.
-  add_type("none", std::make_unique<NoneType>());
+  // the "none" and "_type_" types are included by default.
+  add_type("none", std::make_unique<NullType>("none"));
+  add_type("_type_", std::make_unique<NullType>("_type_"));
 }
 
 /*!
@@ -40,7 +41,7 @@ Type* TypeSystem::add_type(const std::string& name, std::unique_ptr<Type> type)
     // newly defined!
 
     // none/object get to skip these checks because they are roots.
-    if (name != "object" && name != "none") {
+    if (name != "object" && name != "none" && name != "_type_") {
       if (m_forward_declared_types.find(type->get_parent()) != m_forward_declared_types.end()) {
         fmt::print("[TypeSystem] Type {} has incompletely defined parent {}\n", type->get_name(),
                    type->get_parent());
@@ -84,11 +85,24 @@ std::string TypeSystem::get_runtime_type(const TypeSpec& ts) {
 DerefInfo TypeSystem::get_deref_info(const TypeSpec& ts) {
   DerefInfo info;
 
+  if (!ts.has_single_arg()) {
+    // not enough info.
+    info.can_deref = false;
+    return info;
+  }
+
   // default to GPR
   info.reg = RegKind::GPR_64;
   info.mem_deref = true;
 
   if (ts.base_type() == "inline-array") {
+    auto result_type = lookup_type(ts.get_single_arg());
+    auto result_structure_type = dynamic_cast<StructureType*>(result_type);
+    if (!result_structure_type || result_structure_type->is_dynamic()) {
+      info.can_deref = false;
+      return info;
+    }
+
     // it's an inline array of structures. We can "dereference". But really we don't do a memory
     // dereference, we just add stride*idx to the pointer.
     info.can_deref = true;                   // deref operators should work...
@@ -96,7 +110,6 @@ DerefInfo TypeSystem::get_deref_info(const TypeSpec& ts) {
     info.result_type = ts.get_single_arg();  // what we're an inline-array of
     info.sign_extend = false;                // not applicable anyway
 
-    auto result_type = lookup_type(info.result_type);
     if (result_type->is_reference()) {
       info.stride =
           align(result_type->get_size_in_memory(), result_type->get_inline_array_alignment());
@@ -112,11 +125,13 @@ DerefInfo TypeSystem::get_deref_info(const TypeSpec& ts) {
       // in memory, an array of pointers
       info.stride = POINTER_SIZE;
       info.sign_extend = false;
+      info.load_size = POINTER_SIZE;
     } else {
       // an array of values, which should be loaded in the correct way to the correct register
       info.stride = result_type->get_size_in_memory();
       info.sign_extend = result_type->get_load_signed();
       info.reg = result_type->get_preferred_reg_kind();
+      info.load_size = result_type->get_load_size();
       assert(result_type->get_size_in_memory() == result_type->get_load_size());
     }
   } else {
@@ -188,7 +203,7 @@ TypeSpec TypeSystem::make_inline_array_typespec(const TypeSpec& type) {
  * possible, don't store a Type* and store a TypeSpec instead.  The TypeSpec can then be used with
  * lookup_type to find the most up-to-date type information.
  */
-Type* TypeSystem::lookup_type(const std::string& name) {
+Type* TypeSystem::lookup_type(const std::string& name) const {
   auto kv = m_types.find(name);
   if (kv != m_types.end()) {
     return kv->second.get();
@@ -209,7 +224,7 @@ Type* TypeSystem::lookup_type(const std::string& name) {
  * possible, don't store a Type* and store a TypeSpec instead.  The TypeSpec can then be used with
  * lookup_type to find the most up-to-date type information.
  */
-Type* TypeSystem::lookup_type(const TypeSpec& ts) {
+Type* TypeSystem::lookup_type(const TypeSpec& ts) const {
   return lookup_type(ts.base_type());
 }
 
@@ -488,7 +503,7 @@ int TypeSystem::add_field_to_type(StructureType* type,
  * Add types which are built-in to GOAL.
  */
 void TypeSystem::add_builtin_types() {
-  // some of the basic types having confusing circular dependencies, so this is done manually.
+  // some of the basic types have confusing circular dependencies, so this is done manually.
   // there are no inlined things so its ok to do some things out of order because the actual size
   // doesn't really matter.
 
@@ -506,48 +521,53 @@ void TypeSystem::add_builtin_types() {
   auto link_block_type = add_builtin_basic("basic", "link-block");
   auto kheap_type = add_builtin_structure("structure", "kheap");
   auto array_type = add_builtin_basic("basic", "array");
-  auto pair_type = add_builtin_structure("object", "pair");
+  auto pair_type = add_builtin_structure("object", "pair", true);
   auto process_tree_type = add_builtin_basic("basic", "process-tree");
   auto process_type = add_builtin_basic("process-tree", "process");
   auto thread_type = add_builtin_basic("basic", "thread");
   auto connectable_type = add_builtin_structure("structure", "connectable");
   auto stack_frame_type = add_builtin_basic("basic", "stack-frame");
   auto file_stream_type = add_builtin_basic("basic", "file-stream");
-  auto pointer_type = add_builtin_value_type("object", "pointer", 4);
-  auto number_type = add_builtin_value_type("object", "number", 8);  // sign extend?
-  auto float_type = add_builtin_value_type("number", "float", 4, false, false, RegKind::FLOAT);
-  auto integer_type = add_builtin_value_type("number", "integer", 8, false, false);  // sign extend?
-  auto binteger_type =
-      add_builtin_value_type("integer", "binteger", 8, true, false);  // sign extend?
-  auto sinteger_type = add_builtin_value_type("integer", "sinteger", 8, false, true);
-  auto int8_type = add_builtin_value_type("sinteger", "int8", 1, false, true);
-  auto int16_type = add_builtin_value_type("sinteger", "int16", 2, false, true);
-  auto int32_type = add_builtin_value_type("sinteger", "int32", 4, false, true);
-  auto int64_type = add_builtin_value_type("sinteger", "int64", 8, false, true);
-  auto int128_type =
-      add_builtin_value_type("sinteger", "int128", 16, false, true, RegKind::INT_128);
-  auto uinteger_type = add_builtin_value_type("integer", "uinteger", 8);
-  auto uint8_type = add_builtin_value_type("uinteger", "uint8", 1);
-  auto uint16_type = add_builtin_value_type("uinteger", "uint16", 2);
-  auto uint32_type = add_builtin_value_type("uinteger", "uint32", 4);
-  auto uint64_type = add_builtin_value_type("uinteger", "uint64", 81);
-  auto uint128_type =
-      add_builtin_value_type("uinteger", "uint128", 16, false, false, RegKind::INT_128);
+  add_builtin_value_type("object", "pointer", 4);
+  auto inline_array_type = add_builtin_value_type("object", "inline-array", 4);
+  inline_array_type->set_runtime_type("pointer");
+
+  add_builtin_value_type("object", "number", 8);  // sign extend?
+  add_builtin_value_type("number", "float", 4, false, false, RegKind::FLOAT);
+  add_builtin_value_type("number", "integer", 8, false, false);   // sign extend?
+  add_builtin_value_type("integer", "binteger", 8, true, false);  // sign extend?
+  add_builtin_value_type("integer", "sinteger", 8, false, true);
+  add_builtin_value_type("sinteger", "int8", 1, false, true);
+  add_builtin_value_type("sinteger", "int16", 2, false, true);
+  add_builtin_value_type("sinteger", "int32", 4, false, true);
+  add_builtin_value_type("sinteger", "int64", 8, false, true);
+  add_builtin_value_type("sinteger", "int128", 16, false, true, RegKind::INT_128);
+  add_builtin_value_type("integer", "uinteger", 8);
+  add_builtin_value_type("uinteger", "uint8", 1);
+  add_builtin_value_type("uinteger", "uint16", 2);
+  add_builtin_value_type("uinteger", "uint32", 4);
+  add_builtin_value_type("uinteger", "uint64", 81);
+  add_builtin_value_type("uinteger", "uint128", 16, false, false, RegKind::INT_128);
+
+  auto int_type = add_builtin_value_type("integer", "int", 8, false, true);
+  int_type->disallow_in_runtime();
+  auto uint_type = add_builtin_value_type("uinteger", "uint", 8, false, false);
+  uint_type->disallow_in_runtime();
 
   // Methods and Fields
 
   // OBJECT
-  add_method(obj_type, "new", make_function_typespec({"symbol", "type", "int32"}, "object"));
-  add_method(obj_type, "delete", make_function_typespec({"object"}, "none"));
-  add_method(obj_type, "print", make_function_typespec({"object"}, "object"));
-  add_method(obj_type, "inspect", make_function_typespec({"object"}, "object"));
+  add_method(obj_type, "new", make_function_typespec({"symbol", "type", "int32"}, "_type_"));
+  add_method(obj_type, "delete", make_function_typespec({"_type_"}, "none"));
+  add_method(obj_type, "print", make_function_typespec({"_type_"}, "_type_"));
+  add_method(obj_type, "inspect", make_function_typespec({"_type_"}, "_type_"));
   add_method(obj_type, "length",
-             make_function_typespec({"object"}, "int32"));  // todo - this integer type?
-  add_method(obj_type, "asize-of", make_function_typespec({"object"}, "int32"));
-  add_method(obj_type, "copy", make_function_typespec({"object", "symbol"}, "object"));
-  add_method(obj_type, "relocate", make_function_typespec({"object", "int32"}, "object"));
+             make_function_typespec({"_type_"}, "int32"));  // todo - this integer type?
+  add_method(obj_type, "asize-of", make_function_typespec({"_type_"}, "int32"));
+  add_method(obj_type, "copy", make_function_typespec({"_type_", "symbol"}, "_type_"));
+  add_method(obj_type, "relocate", make_function_typespec({"_type_", "int32"}, "_type_"));
   add_method(obj_type, "mem-usage",
-             make_function_typespec({"object"}, "int32"));  // todo - this is a guess.
+             make_function_typespec({"_type_"}, "int32"));  // todo - this is a guess.
 
   // STRUCTURE
   // structure new doesn't support dynamic sizing, which is kinda weird - it grabs the size from
@@ -591,6 +611,38 @@ void TypeSystem::add_builtin_types() {
 
   // VU FUNCTION
   // don't inherit
+  add_field_to_type(vu_function_type, "length", make_typespec("int32"));    // todo integer type
+  add_field_to_type(vu_function_type, "origin", make_typespec("pointer"));  // todo sign extend?
+  add_field_to_type(vu_function_type, "qlength", make_typespec("int32"));   // todo integer type
+
+  // link block
+  builtin_structure_inherit(link_block_type);
+  add_field_to_type(link_block_type, "allocated-length",
+                    make_typespec("int32"));                              // todo integer type
+  add_field_to_type(link_block_type, "version", make_typespec("int32"));  // todo integer type
+  // there's probably some dynamically sized stuff after this...
+
+  // kheap
+  add_field_to_type(kheap_type, "base", make_typespec("pointer"));
+  add_field_to_type(kheap_type, "top", make_typespec("pointer"));
+  add_field_to_type(kheap_type, "current", make_typespec("pointer"));
+  add_field_to_type(kheap_type, "top-base", make_typespec("pointer"));
+
+  // todo
+  (void)array_type;
+
+  // pair
+  pair_type->override_offset(2);
+  add_field_to_type(pair_type, "car", make_typespec("object"));
+  add_field_to_type(pair_type, "cdr", make_typespec("object"));
+
+  // todo, with kernel
+  (void)process_tree_type;
+  (void)process_type;
+  (void)thread_type;
+  (void)connectable_type;
+  (void)stack_frame_type;
+  (void)file_stream_type;
 }
 
 /*!
@@ -625,23 +677,6 @@ int TypeSystem::get_next_method_id(Type* type) {
   }
 }
 
-/*!
- * For debugging, todo remove.
- */
-int TypeSystem::manual_add_field_to_type(StructureType* type,
-                                         const std::string& field_name,
-                                         const TypeSpec& field_type,
-                                         int offset,
-                                         int size,
-                                         int alignment) {
-  Field field(field_name, field_type);
-  field.set_alignment(alignment);
-  field.set_offset(offset);
-  int new_size = type->get_size_in_memory() + size;
-  type->add_field(field, new_size);
-  return offset;
-}
-
 /*!
  * Lookup a field of a type by name
  */
@@ -725,8 +760,9 @@ int TypeSystem::get_size_in_type(const Field& field) {
  * things in the wrong order.
  */
 StructureType* TypeSystem::add_builtin_structure(const std::string& parent,
-                                                 const std::string& type_name) {
-  add_type(type_name, std::make_unique<StructureType>(parent, type_name));
+                                                 const std::string& type_name,
+                                                 bool boxed) {
+  add_type(type_name, std::make_unique<StructureType>(parent, type_name, boxed));
   return get_type_of_type<StructureType>(type_name);
 }
 
@@ -759,4 +795,172 @@ ValueType* TypeSystem::add_builtin_value_type(const std::string& parent,
  */
 void TypeSystem::builtin_structure_inherit(StructureType* st) {
   st->inherit(get_type_of_type<StructureType>(st->get_parent()));
+}
+
+/*!
+ * Main compile-time type check!
+ * @param expected - the expected type
+ * @param actual - the actual type (can be more specific)
+ * @param error_source_name - optional, can provide a name for where the error comes from
+ * @param print_on_error - print a message explaining the type error, if there is one
+ * @param throw_on_error - throw a std::runtime_error on failure if set.
+ * @return if the type check passes
+ */
+bool TypeSystem::typecheck(const TypeSpec& expected,
+                           const TypeSpec& actual,
+                           const std::string& error_source_name,
+                           bool print_on_error,
+                           bool throw_on_error) const {
+  bool success = true;
+  // first, typecheck the base types:
+  if (!typecheck_base_types(expected.base_type(), actual.base_type())) {
+    success = false;
+  }
+
+  // next argument checks:
+  if (expected.m_arguments.size() == actual.m_arguments.size()) {
+    for (size_t i = 0; i < expected.m_arguments.size(); i++) {
+      // don't print/throw because the error would be confusing. Better to fail only the
+      // outer most check and print a single error message.
+      if (!typecheck(expected.m_arguments[i], actual.m_arguments[i], "", false, false)) {
+        success = false;
+        break;
+      }
+    }
+  } else {
+    // different sizes of arguments.
+    if (expected.m_arguments.empty()) {
+      // we expect zero arguments, but got some. The actual type is more specific, so this is fine.
+    } else {
+      // different sizes, and we expected arguments. No good!
+      success = false;
+    }
+  }
+
+  if (!success) {
+    if (print_on_error) {
+      if (error_source_name.empty()) {
+        fmt::print("[TypeSystem] Got type \"{}\" when expecting \"{}\"\n", actual.print(),
+                   expected.print());
+      } else {
+        fmt::print("[TypeSystem] For {}, got type \"{}\" when expecting \"{}\"\n",
+                   error_source_name, actual.print(), expected.print());
+      }
+    }
+
+    if (throw_on_error) {
+      throw std::runtime_error("typecheck failed");
+    }
+  }
+
+  return success;
+}
+
+/*!
+ * Is actual of type expected? For base types.
+ */
+bool TypeSystem::typecheck_base_types(const std::string& expected,
+                                      const std::string& actual) const {
+  // just to make sure it exists. (note - could there be a case when it just has to be forward
+  // declared, but not defined?)
+  lookup_type(expected);
+
+  if (expected == actual) {
+    lookup_type(actual);  // make sure it exists
+    return true;
+  }
+
+  std::string actual_name = actual;
+  auto actual_type = lookup_type(actual_name);
+  while (actual_type->has_parent()) {
+    actual_name = actual_type->get_parent();
+    actual_type = lookup_type(actual_name);
+
+    if (expected == actual_name) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/*!
+ * Get a path from type to object.
+ */
+std::vector<std::string> TypeSystem::get_path_up_tree(const std::string& type) {
+  auto parent = lookup_type(type)->get_parent();
+  std::vector<std::string> path = {type};
+  path.push_back(parent);
+  auto parent_type = lookup_type(parent);
+
+  while (parent_type->has_parent()) {
+    parent = parent_type->get_parent();
+    parent_type = lookup_type(parent);
+    path.push_back(parent);
+  }
+
+  return path;
+}
+
+/*!
+ * Lowest common ancestor of two base types.
+ */
+std::string TypeSystem::lca_base(const std::string& a, const std::string& b) {
+  if (a == b) {
+    return a;
+  }
+
+  auto a_up = get_path_up_tree(a);
+  auto b_up = get_path_up_tree(b);
+
+  int ai = a_up.size() - 1;
+  int bi = b_up.size() - 1;
+
+  std::string* result = nullptr;
+  while (ai >= 0 && bi >= 0) {
+    if (a_up.at(ai) == b_up.at(bi)) {
+      result = &a_up.at(ai);
+    } else {
+      break;
+    }
+    ai--;
+    bi--;
+  }
+
+  assert(result);
+  return *result;
+}
+
+/*!
+ * Lowest common ancestor of two typespecs.  Will recursively apply to arguments, if compatible.
+ * Otherwise arguments are stripped off.
+ * In a situation like lca("(a b)", "(c d)"), the result will be
+ * (lca(a, b) lca(b, d)).
+ */
+TypeSpec TypeSystem::lowest_common_ancestor(const TypeSpec& a, const TypeSpec& b) {
+  auto result = make_typespec(lca_base(a.base_type(), b.base_type()));
+  if (!a.m_arguments.empty() && !b.m_arguments.empty() &&
+      a.m_arguments.size() == b.m_arguments.size()) {
+    // recursively add arguments
+    for (size_t i = 0; i < a.m_arguments.size(); i++) {
+      result.add_arg(lowest_common_ancestor(a.m_arguments.at(i), b.m_arguments.at(i)));
+    }
+  }
+  return result;
+}
+
+/*!
+ * Lowest common ancestor of multiple (or at least one) type.
+ */
+TypeSpec TypeSystem::lowest_common_ancestor(const std::vector<TypeSpec>& types) {
+  assert(!types.empty());
+  if (types.size() == 1) {
+    return types.front();
+  }
+
+  auto result = lowest_common_ancestor(types.at(0), types.at(1));
+  for (size_t i = 2; i < types.size(); i++) {
+    result = lowest_common_ancestor(result, types.at(i));
+  }
+  return result;
 }
\ No newline at end of file
diff --git a/common/type_system/TypeSystem.h b/common/type_system/TypeSystem.h
index 71a865588b..722ca515ae 100644
--- a/common/type_system/TypeSystem.h
+++ b/common/type_system/TypeSystem.h
@@ -23,6 +23,7 @@ struct DerefInfo {
   bool sign_extend = false;
   RegKind reg = RegKind::INVALID;
   int stride = -1;
+  int load_size = -1;
   TypeSpec result_type;
 };
 
@@ -45,8 +46,8 @@ class TypeSystem {
   TypeSpec make_inline_array_typespec(const std::string& type);
   TypeSpec make_inline_array_typespec(const TypeSpec& type);
 
-  Type* lookup_type(const TypeSpec& ts);
-  Type* lookup_type(const std::string& name);
+  Type* lookup_type(const TypeSpec& ts) const;
+  Type* lookup_type(const std::string& name) const;
 
   MethodInfo add_method(Type* type, const std::string& method_name, const TypeSpec& ts);
   MethodInfo add_new_method(Type* type, const TypeSpec& ts);
@@ -67,6 +68,12 @@ class TypeSystem {
   void add_builtin_types();
 
   std::string print_all_type_information() const;
+  bool typecheck(const TypeSpec& expected,
+                 const TypeSpec& actual,
+                 const std::string& error_source_name = "",
+                 bool print_on_error = true,
+                 bool throw_on_error = true) const;
+  std::vector<std::string> get_path_up_tree(const std::string& type);
 
   /*!
    * Get a type by name and cast to a child class of Type*. Must succeed.
@@ -81,19 +88,19 @@ class TypeSystem {
     return result;
   }
 
+  TypeSpec lowest_common_ancestor(const TypeSpec& a, const TypeSpec& b);
+  TypeSpec lowest_common_ancestor(const std::vector<TypeSpec>& types);
+
  private:
+  std::string lca_base(const std::string& a, const std::string& b);
+  bool typecheck_base_types(const std::string& expected, const std::string& actual) const;
   int get_size_in_type(const Field& field);
   int get_alignment_in_type(const Field& field);
   Field lookup_field(const std::string& type_name, const std::string& field_name);
   int get_next_method_id(Type* type);
-  int manual_add_field_to_type(StructureType* type,
-                               const std::string& field_name,
-                               const TypeSpec& field_type,
-                               int offset,
-                               int size,
-                               int alignment);
-
-  StructureType* add_builtin_structure(const std::string& parent, const std::string& type_name);
+  StructureType* add_builtin_structure(const std::string& parent,
+                                       const std::string& type_name,
+                                       bool boxed = false);
   BasicType* add_builtin_basic(const std::string& parent, const std::string& type_name);
   ValueType* add_builtin_value_type(const std::string& parent,
                                     const std::string& type_name,
@@ -104,7 +111,6 @@ class TypeSystem {
   void builtin_structure_inherit(StructureType* st);
 
   std::unordered_map<std::string, std::unique_ptr<Type>> m_types;
-  std::unordered_map<std::string, Type*> m_global_types;
   std::unordered_set<std::string> m_forward_declared_types;
   std::vector<std::unique_ptr<Type>> m_old_types;
 
diff --git a/common/type_system/type_util.h b/common/type_system/type_util.h
index 4e87474578..fcefbdd2ad 100644
--- a/common/type_system/type_util.h
+++ b/common/type_system/type_util.h
@@ -1,9 +1,9 @@
 #ifndef JAK_TYPE_UTIL_H
 #define JAK_TYPE_UTIL_H
 
-template<typename T>
+template <typename T>
 T align(T current, T alignment, T offset = 0) {
-  while((current % alignment) != 0) {
+  while ((current % alignment) != 0) {
     current++;
   }
   return current + offset;
diff --git a/common/versions.h b/common/versions.h
index 74b1ec0169..5ecb742ac8 100644
--- a/common/versions.h
+++ b/common/versions.h
@@ -12,7 +12,7 @@ namespace versions {
 // language version
 constexpr s32 GOAL_VERSION_MAJOR = 2;
 constexpr s32 GOAL_VERSION_MINOR = 6;
-}
+}  // namespace versions
 
 // GOAL kernel version
 constexpr int KERNEL_VERSION_MAJOR = 2;
diff --git a/decompiler/Function/Function.h b/decompiler/Function/Function.h
index d8bfeba202..c972496229 100644
--- a/decompiler/Function/Function.h
+++ b/decompiler/Function/Function.h
@@ -9,18 +9,18 @@
 
 struct FunctionName {
   enum class FunctionKind {
-    UNIDENTIFIED, // hasn't been identified yet.
-    GLOBAL, // global named function
+    UNIDENTIFIED,  // hasn't been identified yet.
+    GLOBAL,        // global named function
     METHOD,
     TOP_LEVEL_INIT,
   } kind = FunctionKind::UNIDENTIFIED;
 
-  std::string function_name; // only applicable for GLOBAL
-  std::string type_name;     // only applicable for METHOD
-  int method_id = -1;        // only applicable for METHOD
+  std::string function_name;  // only applicable for GLOBAL
+  std::string type_name;      // only applicable for METHOD
+  int method_id = -1;         // only applicable for METHOD
 
   std::string to_string() const {
-    switch(kind) {
+    switch (kind) {
       case FunctionKind::GLOBAL:
         return function_name;
       case FunctionKind::METHOD:
@@ -34,13 +34,9 @@ struct FunctionName {
     }
   }
 
-  bool empty() const {
-    return kind == FunctionKind::UNIDENTIFIED;
-  }
+  bool empty() const { return kind == FunctionKind::UNIDENTIFIED; }
 
-  void set_as_top_level() {
-    kind = FunctionKind::TOP_LEVEL_INIT;
-  }
+  void set_as_top_level() { kind = FunctionKind::TOP_LEVEL_INIT; }
 
   void set_as_global(std::string name) {
     kind = FunctionKind::GLOBAL;
diff --git a/decompiler/ObjectFile/LinkedObjectFile.cpp b/decompiler/ObjectFile/LinkedObjectFile.cpp
index d02fc3bf31..be9eaa1de7 100644
--- a/decompiler/ObjectFile/LinkedObjectFile.cpp
+++ b/decompiler/ObjectFile/LinkedObjectFile.cpp
@@ -90,7 +90,7 @@ Function& LinkedObjectFile::get_function_at_label(int label_id) {
   }
 
   assert(false);
-  return functions_by_seg.front().front(); // to avoid error
+  return functions_by_seg.front().front();  // to avoid error
 }
 
 /*!
@@ -520,7 +520,7 @@ std::string LinkedObjectFile::print_disassembly() {
       result += "; .function " + func.guessed_name.to_string() + "\n";
       result += ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n";
       result += func.prologue.to_string(2) + "\n";
-      if(!func.warnings.empty()) {
+      if (!func.warnings.empty()) {
         result += "Warnings: " + func.warnings + "\n";
       }
 
@@ -581,11 +581,11 @@ std::string LinkedObjectFile::print_disassembly() {
       //      }
 
       // hack
-      if(func.cfg && !func.cfg->is_fully_resolved()) {
+      if (func.cfg && !func.cfg->is_fully_resolved()) {
         result += func.cfg->to_dot();
         result += "\n";
       }
-      if(func.cfg) {
+      if (func.cfg) {
         result += func.cfg->to_form_string() + "\n";
 
         // To debug block stuff.
@@ -614,7 +614,6 @@ std::string LinkedObjectFile::print_disassembly() {
          */
       }
 
-
       result += "\n\n\n";
     }
 
@@ -636,7 +635,6 @@ std::string LinkedObjectFile::print_disassembly() {
 
       if (word.kind == LinkedWord::TYPE_PTR && word.symbol_name == "string") {
         result += "; " + get_goal_string(seg, i) + "\n";
-
       }
     }
   }
diff --git a/decompiler/ObjectFile/LinkedObjectFile.h b/decompiler/ObjectFile/LinkedObjectFile.h
index 4b87dbe345..f897b86475 100644
--- a/decompiler/ObjectFile/LinkedObjectFile.h
+++ b/decompiler/ObjectFile/LinkedObjectFile.h
@@ -15,7 +15,6 @@
 #include "decompiler/Function/Function.h"
 #include "decompiler/util/LispPrint.h"
 
-
 /*!
  * A label to a location in this object file.
  * Doesn't have to be word aligned.
@@ -23,14 +22,14 @@
 struct Label {
   std::string name;
   int target_segment;
-  int offset; // in bytes
+  int offset;  // in bytes
 };
 
 /*!
  * An object file's data with linking information included.
  */
 class LinkedObjectFile {
-public:
+ public:
   LinkedObjectFile() = default;
   void set_segment_count(int n_segs);
   void push_back_word_to_segment(uint32_t word, int segment);
@@ -38,8 +37,15 @@ public:
   int get_label_at(int seg, int offset) const;
   bool label_points_to_code(int label_id) const;
   bool pointer_link_word(int source_segment, int source_offset, int dest_segment, int dest_offset);
-  void pointer_link_split_word(int source_segment, int source_hi_offset, int source_lo_offset, int dest_segment, int dest_offset);
-  void symbol_link_word(int source_segment, int source_offset, const char* name, LinkedWord::Kind kind);
+  void pointer_link_split_word(int source_segment,
+                               int source_hi_offset,
+                               int source_lo_offset,
+                               int dest_segment,
+                               int dest_offset);
+  void symbol_link_word(int source_segment,
+                        int source_offset,
+                        const char* name,
+                        LinkedWord::Kind kind);
   void symbol_link_offset(int source_segment, int source_offset, const char* name);
   Function& get_function_at_label(int label_id);
   std::string get_label_name(int label_id) const;
@@ -83,7 +89,6 @@ public:
     uint32_t n_fp_reg_use = 0;
     uint32_t n_fp_reg_use_resolved = 0;
 
-
     void add(const Stats& other) {
       total_code_bytes += other.total_code_bytes;
       total_v2_code_bytes += other.total_v2_code_bytes;
@@ -116,9 +121,9 @@ public:
   std::vector<std::vector<Function>> functions_by_seg;
   std::vector<Label> labels;
 
-private:
+ private:
   std::shared_ptr<Form> to_form_script(int seg, int word_idx, std::vector<bool>& seen);
-  std::shared_ptr<Form> to_form_script_object(int seg, int byte_idx, std::vector<bool> &seen);
+  std::shared_ptr<Form> to_form_script_object(int seg, int byte_idx, std::vector<bool>& seen);
   bool is_empty_list(int seg, int byte_idx);
   bool is_string(int seg, int byte_idx);
   std::string get_goal_string(int seg, int word_idx);
@@ -126,6 +131,4 @@ private:
   std::vector<std::unordered_map<int, int>> label_per_seg_by_offset;
 };
 
-
-
-#endif //NEXT_LINKEDOBJECTFILE_H
+#endif  // NEXT_LINKEDOBJECTFILE_H
diff --git a/decompiler/ObjectFile/LinkedObjectFileCreation.cpp b/decompiler/ObjectFile/LinkedObjectFileCreation.cpp
index d61b515224..91cfa2b19f 100644
--- a/decompiler/ObjectFile/LinkedObjectFileCreation.cpp
+++ b/decompiler/ObjectFile/LinkedObjectFileCreation.cpp
@@ -213,7 +213,6 @@ static uint32_t align16(uint32_t in) {
   return (in + 15) & (~15);
 }
 
-
 /*!
  * Process link data for a "V4" object file.
  * In reality a V4 seems to be just a V2 object, but with the link data after the real data.
diff --git a/decompiler/ObjectFile/LinkedObjectFileCreation.h b/decompiler/ObjectFile/LinkedObjectFileCreation.h
index 8a3461a56b..245356b176 100644
--- a/decompiler/ObjectFile/LinkedObjectFileCreation.h
+++ b/decompiler/ObjectFile/LinkedObjectFileCreation.h
@@ -11,4 +11,4 @@
 
 LinkedObjectFile to_linked_object_file(const std::vector<uint8_t>& data, const std::string& name);
 
-#endif //NEXT_LINKEDOBJECTFILECREATION_H
+#endif  // NEXT_LINKEDOBJECTFILECREATION_H
diff --git a/decompiler/ObjectFile/ObjectFileDB.cpp b/decompiler/ObjectFile/ObjectFileDB.cpp
index 07f6f89740..eb7c2cd045 100644
--- a/decompiler/ObjectFile/ObjectFileDB.cpp
+++ b/decompiler/ObjectFile/ObjectFileDB.cpp
@@ -421,8 +421,8 @@ void ObjectFileDB::analyze_functions() {
       (void)segment_id;
       auto name = func.guessed_name.to_string();
       if (func.guessed_name.expected_unique()) {
-        if(unique_names.find(name) != unique_names.end()) {
-            duplicated_functions[name].insert(data.record.to_unique_name());
+        if (unique_names.find(name) != unique_names.end()) {
+          duplicated_functions[name].insert(data.record.to_unique_name());
         }
 
         unique_names.insert(name);
@@ -435,22 +435,22 @@ void ObjectFileDB::analyze_functions() {
     });
 
     for_each_function([&](Function& func, int segment_id, ObjectFileData& data) {
-        (void)segment_id;
-        auto name = func.guessed_name.to_string();
-        if(func.guessed_name.expected_unique()) {
-          if(duplicated_functions.find(name) != duplicated_functions.end()) {
-            duplicated_functions[name].insert(data.record.to_unique_name());
-            func.warnings += "this function exists in multiple non-identical object files";
-          }
+      (void)segment_id;
+      auto name = func.guessed_name.to_string();
+      if (func.guessed_name.expected_unique()) {
+        if (duplicated_functions.find(name) != duplicated_functions.end()) {
+          duplicated_functions[name].insert(data.record.to_unique_name());
+          func.warnings += "this function exists in multiple non-identical object files";
         }
+      }
     });
 
-//    for(const auto& kv : duplicated_functions) {
-//      printf("Function %s is found in non-identical object files:\n", kv.first.c_str());
-//      for(const auto& obj : kv.second) {
-//        printf(" %s\n", obj.c_str());
-//      }
-//    }
+    //    for(const auto& kv : duplicated_functions) {
+    //      printf("Function %s is found in non-identical object files:\n", kv.first.c_str());
+    //      for(const auto& obj : kv.second) {
+    //        printf(" %s\n", obj.c_str());
+    //      }
+    //    }
   }
 
   int total_nontrivial_functions = 0;
@@ -466,45 +466,48 @@ void ObjectFileDB::analyze_functions() {
       total_basic_blocks += blocks.size();
       func.basic_blocks = blocks;
 
-      if(!func.suspected_asm) {
-          func.analyze_prologue(data.linked_data);
-          func.cfg = build_cfg(data.linked_data, segment_id, func);
-          total_functions++;
-          if (func.cfg->is_fully_resolved()) {
-              resolved_cfg_functions++;
-          }
+      if (!func.suspected_asm) {
+        func.analyze_prologue(data.linked_data);
+        func.cfg = build_cfg(data.linked_data, segment_id, func);
+        total_functions++;
+        if (func.cfg->is_fully_resolved()) {
+          resolved_cfg_functions++;
+        }
       } else {
         resolved_cfg_functions++;
       }
 
-
-      if(func.basic_blocks.size() > 1 && !func.suspected_asm) {
+      if (func.basic_blocks.size() > 1 && !func.suspected_asm) {
         total_nontrivial_functions++;
-        if(func.cfg->is_fully_resolved()) {
+        if (func.cfg->is_fully_resolved()) {
           total_resolved_nontrivial_functions++;
         } else {
-          if(!func.guessed_name.empty()) {
-            unresolved_by_length[func.end_word - func.start_word].push_back(func.guessed_name.to_string());
+          if (!func.guessed_name.empty()) {
+            unresolved_by_length[func.end_word - func.start_word].push_back(
+                func.guessed_name.to_string());
           }
         }
       }
 
-      if(!func.guessed_name.empty()) {
+      if (!func.guessed_name.empty()) {
         total_named_functions++;
       }
     });
 
-    printf("Found %d functions (%d with nontrivial cfgs)\n", total_functions, total_nontrivial_functions);
-    printf("Named %d/%d functions (%.2f%%)\n", total_named_functions, total_functions, 100.f * float(total_named_functions) / float(total_functions));
+    printf("Found %d functions (%d with nontrivial cfgs)\n", total_functions,
+           total_nontrivial_functions);
+    printf("Named %d/%d functions (%.2f%%)\n", total_named_functions, total_functions,
+           100.f * float(total_named_functions) / float(total_functions));
     printf("Found %d basic blocks in %.3f ms\n", total_basic_blocks, timer.getMs());
-    printf(" %d/%d functions passed cfg analysis stage (%.2f%%)\n", resolved_cfg_functions, total_functions,
-           100.f * float(resolved_cfg_functions) / float(total_functions));
-    printf(" %d/%d nontrivial cfg's resolved (%.2f%%)\n", total_resolved_nontrivial_functions, total_nontrivial_functions,
+    printf(" %d/%d functions passed cfg analysis stage (%.2f%%)\n", resolved_cfg_functions,
+           total_functions, 100.f * float(resolved_cfg_functions) / float(total_functions));
+    printf(" %d/%d nontrivial cfg's resolved (%.2f%%)\n", total_resolved_nontrivial_functions,
+           total_nontrivial_functions,
            100.f * float(total_resolved_nontrivial_functions) / float(total_nontrivial_functions));
 
-    for(auto& kv : unresolved_by_length) {
+    for (auto& kv : unresolved_by_length) {
       printf("LEN %d\n", kv.first);
-      for(auto& x : kv.second) {
+      for (auto& x : kv.second) {
         printf("  %s\n", x.c_str());
       }
     }
diff --git a/decompiler/ObjectFile/ObjectFileDB.h b/decompiler/ObjectFile/ObjectFileDB.h
index 6beac4d1d2..3dda56821b 100644
--- a/decompiler/ObjectFile/ObjectFileDB.h
+++ b/decompiler/ObjectFile/ObjectFileDB.h
@@ -60,8 +60,8 @@ class ObjectFileDB {
   template <typename Func>
   void for_each_obj(Func f) {
     assert(obj_files_by_name.size() == obj_file_order.size());
-    for(const auto& name : obj_file_order) {
-      for(auto& obj : obj_files_by_name.at(name)) {
+    for (const auto& name : obj_file_order) {
+      for (auto& obj : obj_files_by_name.at(name)) {
         f(obj);
       }
     }
@@ -75,12 +75,12 @@ class ObjectFileDB {
   template <typename Func>
   void for_each_function(Func f) {
     for_each_obj([&](ObjectFileData& data) {
-//      printf("IN %s\n", data.record.to_unique_name().c_str());
+      //      printf("IN %s\n", data.record.to_unique_name().c_str());
       for (int i = 0; i < int(data.linked_data.segments); i++) {
-//        printf("seg %d\n", i);
+        //        printf("seg %d\n", i);
         int fn = 0;
         for (auto& goal_func : data.linked_data.functions_by_seg.at(i)) {
-//          printf("fn %d\n", fn);
+          //          printf("fn %d\n", fn);
           f(goal_func, i, data);
           fn++;
         }
diff --git a/decompiler/TypeSystem/GoalFunction.h b/decompiler/TypeSystem/GoalFunction.h
index dbb94b32cf..9f593a3ff7 100644
--- a/decompiler/TypeSystem/GoalFunction.h
+++ b/decompiler/TypeSystem/GoalFunction.h
@@ -3,13 +3,13 @@
 
 class GoalFunction {
  public:
-//  enum Kind {
-//    GLOBAL_FUNCTION,
-//    ANON_FUNCTION,
-//    METHOD,
-//    BEHAVIOR,
-//    UNKNOWN
-//  };
+  //  enum Kind {
+  //    GLOBAL_FUNCTION,
+  //    ANON_FUNCTION,
+  //    METHOD,
+  //    BEHAVIOR,
+  //    UNKNOWN
+  //  };
 };
 
 #endif  // JAK_DISASSEMBLER_GOALFUNCTION_H
diff --git a/decompiler/TypeSystem/GoalSymbol.h b/decompiler/TypeSystem/GoalSymbol.h
index 1f34d51abd..f4481f5d1e 100644
--- a/decompiler/TypeSystem/GoalSymbol.h
+++ b/decompiler/TypeSystem/GoalSymbol.h
@@ -13,14 +13,13 @@ class GoalSymbol {
     m_has_type_info = true;
   }
 
-  bool has_type_info() const {
-    return m_has_type_info;
-  }
+  bool has_type_info() const { return m_has_type_info; }
 
   void set_type(TypeSpec ts) {
-    if(m_has_type_info) {
-      if(ts != m_type) {
-        printf("symbol %s %s -> %s", m_name.c_str(), m_type.to_string().c_str(), ts.to_string().c_str());
+    if (m_has_type_info) {
+      if (ts != m_type) {
+        printf("symbol %s %s -> %s", m_name.c_str(), m_type.to_string().c_str(),
+               ts.to_string().c_str());
         assert(false);
       }
     }
diff --git a/decompiler/TypeSystem/GoalType.h b/decompiler/TypeSystem/GoalType.h
index 71c456a3b3..553f3c91a8 100644
--- a/decompiler/TypeSystem/GoalType.h
+++ b/decompiler/TypeSystem/GoalType.h
@@ -6,14 +6,10 @@
 class GoalType {
  public:
   GoalType() = default;
-  GoalType(std::string name) : m_name(std::move(name)) { }
-  bool has_info() const {
-    return m_has_info;
-  }
+  GoalType(std::string name) : m_name(std::move(name)) {}
+  bool has_info() const { return m_has_info; }
 
-  bool has_method_count() const {
-    return m_method_count_set;
-  }
+  bool has_method_count() const { return m_method_count_set; }
 
   void set_methods(int n);
 
diff --git a/decompiler/TypeSystem/TypeInfo.cpp b/decompiler/TypeSystem/TypeInfo.cpp
index d340db191a..db8e4127fd 100644
--- a/decompiler/TypeSystem/TypeInfo.cpp
+++ b/decompiler/TypeSystem/TypeInfo.cpp
@@ -48,9 +48,10 @@ std::string TypeInfo::get_summary() {
           " Total Types: %d\n"
           "   with info: %d (%.2f%%)\n"
           "   with method count: %d (%.2f%%)\n",
-          total_symbols, syms_with_type_info, 100.f * float(syms_with_type_info) / float(total_symbols),
-          total_types, types_with_info, 100.f * float(types_with_info) / float(total_types),
-          types_with_method_count, 100.f * float(types_with_method_count) / float(total_types));
+          total_symbols, syms_with_type_info,
+          100.f * float(syms_with_type_info) / float(total_symbols), total_types, types_with_info,
+          100.f * float(types_with_info) / float(total_types), types_with_method_count,
+          100.f * float(types_with_method_count) / float(total_types));
 
   return {buffer};
 }
@@ -67,7 +68,7 @@ void TypeInfo::inform_symbol_with_no_type_info(const std::string& name) {
   }
 }
 
-void TypeInfo::inform_symbol(const std::string &name, TypeSpec type) {
+void TypeInfo::inform_symbol(const std::string& name, TypeSpec type) {
   inform_symbol_with_no_type_info(name);
   m_symbols.at(name).set_type(std::move(type));
 }
@@ -88,10 +89,10 @@ void TypeInfo::inform_type_method_count(const std::string& name, int methods) {
 
 std::string TypeInfo::get_all_symbols_debug() {
   std::string result = "const char* all_syms[" + std::to_string(m_symbols.size()) + "] = {";
-  for(auto& x : m_symbols) {
+  for (auto& x : m_symbols) {
     result += "\"" + x.first + "\",";
   }
-  if(!result.empty()) {
+  if (!result.empty()) {
     result.pop_back();
   }
   return result + "};";
diff --git a/decompiler/TypeSystem/TypeSpec.h b/decompiler/TypeSystem/TypeSpec.h
index f24f1bb87e..6657362302 100644
--- a/decompiler/TypeSystem/TypeSpec.h
+++ b/decompiler/TypeSystem/TypeSpec.h
@@ -8,8 +8,9 @@
 class TypeSpec {
  public:
   TypeSpec() = default;
-  explicit TypeSpec(std::string base_type) : m_base_type(std::move(base_type)) { }
-  TypeSpec(std::string base_type, std::vector<TypeSpec> args) : m_base_type(std::move(base_type)), m_args(std::move(args)) { }
+  explicit TypeSpec(std::string base_type) : m_base_type(std::move(base_type)) {}
+  TypeSpec(std::string base_type, std::vector<TypeSpec> args)
+      : m_base_type(std::move(base_type)), m_args(std::move(args)) {}
 
   std::string to_string() const;
   std::shared_ptr<Form> to_form() const;
diff --git a/decompiler/main.cpp b/decompiler/main.cpp
index 29125d3557..1deb4d4d05 100644
--- a/decompiler/main.cpp
+++ b/decompiler/main.cpp
@@ -47,7 +47,7 @@ int main(int argc, char** argv) {
   }
 
   printf("%s\n", get_type_info().get_summary().c_str());
-//  printf("%d\n", InstructionKind::EE_OP_MAX);
-//  printf("%s\n", get_type_info().get_all_symbols_debug().c_str());
+  //  printf("%d\n", InstructionKind::EE_OP_MAX);
+  //  printf("%s\n", get_type_info().get_all_symbols_debug().c_str());
   return 0;
 }
diff --git a/decompiler/util/BinaryReader.h b/decompiler/util/BinaryReader.h
index b98a08731f..c0e3c9746a 100644
--- a/decompiler/util/BinaryReader.h
+++ b/decompiler/util/BinaryReader.h
@@ -6,14 +6,13 @@
 #include <vector>
 
 class BinaryReader {
-public:
-  BinaryReader(uint8_t* _buffer, uint32_t _size) : buffer(_buffer), size(_size) {
+ public:
+  BinaryReader(uint8_t* _buffer, uint32_t _size) : buffer(_buffer), size(_size) {}
 
-  }
+  explicit BinaryReader(std::vector<uint8_t>& _buffer)
+      : buffer((uint8_t*)_buffer.data()), size(_buffer.size()) {}
 
-  explicit BinaryReader(std::vector<uint8_t>& _buffer) : buffer((uint8_t*)_buffer.data()), size(_buffer.size()) { }
-
-  template<typename T>
+  template <typename T>
   T read() {
     assert(seek + sizeof(T) <= size);
     T& obj = *(T*)(buffer + seek);
@@ -26,23 +25,16 @@ public:
     assert(seek <= size);
   }
 
-  uint32_t bytes_left() const {
-    return size - seek;
-  }
+  uint32_t bytes_left() const { return size - seek; }
 
-  uint8_t* here() {
-    return buffer + seek;
-  }
+  uint8_t* here() { return buffer + seek; }
 
-  uint32_t get_seek() {
-    return seek;
-  }
+  uint32_t get_seek() { return seek; }
 
-private:
+ private:
   uint8_t* buffer;
   uint32_t size;
   uint32_t seek = 0;
 };
 
-
-#endif //JAK_V2_BINARYREADER_H
+#endif  // JAK_V2_BINARYREADER_H
diff --git a/decompiler/util/FileIO.cpp b/decompiler/util/FileIO.cpp
index 914d647d59..5466d18653 100644
--- a/decompiler/util/FileIO.cpp
+++ b/decompiler/util/FileIO.cpp
@@ -16,7 +16,8 @@ std::string combine_path(const std::string& parent, const std::string& child) {
 
 std::vector<uint8_t> read_binary_file(const std::string& filename) {
   auto fp = fopen(filename.c_str(), "rb");
-  if(!fp) throw std::runtime_error("File " + filename + " cannot be opened");
+  if (!fp)
+    throw std::runtime_error("File " + filename + " cannot be opened");
   fseek(fp, 0, SEEK_END);
   auto len = ftell(fp);
   rewind(fp);
@@ -24,7 +25,7 @@ std::vector<uint8_t> read_binary_file(const std::string& filename) {
   std::vector<uint8_t> data;
   data.resize(len);
 
-  if(fread(data.data(), len, 1, fp) != 1) {
+  if (fread(data.data(), len, 1, fp) != 1) {
     throw std::runtime_error("File " + filename + " cannot be read");
   }
 
@@ -34,8 +35,8 @@ std::vector<uint8_t> read_binary_file(const std::string& filename) {
 std::string base_name(const std::string& filename) {
   size_t pos = 0;
   assert(!filename.empty());
-  for(size_t i = filename.size() - 1; i-- > 0;) {
-    if(filename.at(i) == '/') {
+  for (size_t i = filename.size() - 1; i-- > 0;) {
+    if (filename.at(i) == '/') {
       pos = (i + 1);
       break;
     }
@@ -66,14 +67,13 @@ uint32_t crc32(const uint8_t* data, size_t size) {
   return ~crc;
 }
 
-
 uint32_t crc32(const std::vector<uint8_t>& data) {
   return crc32(data.data(), data.size());
 }
 
 void write_text_file(const std::string& file_name, const std::string& text) {
   FILE* fp = fopen(file_name.c_str(), "w");
-  if(!fp) {
+  if (!fp) {
     printf("Failed to fopen %s\n", file_name.c_str());
     throw std::runtime_error("Failed to open file");
   }
diff --git a/decompiler/util/FileIO.h b/decompiler/util/FileIO.h
index 8085085a09..8f02577f4c 100644
--- a/decompiler/util/FileIO.h
+++ b/decompiler/util/FileIO.h
@@ -14,4 +14,4 @@ void init_crc();
 uint32_t crc32(const uint8_t* data, size_t size);
 uint32_t crc32(const std::vector<uint8_t>& data);
 
-#endif //JAK_V2_FILEIO_H
+#endif  // JAK_V2_FILEIO_H
diff --git a/decompiler/util/LispPrint.cpp b/decompiler/util/LispPrint.cpp
index 103fa42f5a..3031cd7ead 100644
--- a/decompiler/util/LispPrint.cpp
+++ b/decompiler/util/LispPrint.cpp
@@ -45,11 +45,11 @@ std::string Form::toStringSimple() {
   return result;
 }
 
-void Form::buildStringSimple(std::string &str) {
+void Form::buildStringSimple(std::string& str) {
   std::vector<FormToken> tokens;
   toTokenList(tokens);
-  for(auto& token : tokens) {
-    switch(token.kind) {
+  for (auto& token : tokens) {
+    switch (token.kind) {
       case TokenKind::WHITESPACE:
         str.push_back(' ');
         break;
@@ -77,26 +77,25 @@ void Form::buildStringSimple(std::string &str) {
   }
 }
 
-void Form::toTokenList(std::vector<FormToken> &tokens) {
-  switch(kind) {
+void Form::toTokenList(std::vector<FormToken>& tokens) {
+  switch (kind) {
     case FormKind::SYMBOL:
       tokens.emplace_back(TokenKind::SYMBOL, symbol);
       break;
-    case FormKind::PAIR:
-    {
+    case FormKind::PAIR: {
       tokens.emplace_back(TokenKind::OPEN_PAREN);
       Form* toPrint = this;
-      for(;;) {
-        if(toPrint->kind == FormKind::PAIR) {
-          toPrint->pair[0]->toTokenList(tokens); // print CAR
+      for (;;) {
+        if (toPrint->kind == FormKind::PAIR) {
+          toPrint->pair[0]->toTokenList(tokens);  // print CAR
           toPrint = toPrint->pair[1].get();
-          if(toPrint->kind == FormKind::EMPTY_LIST) {
+          if (toPrint->kind == FormKind::EMPTY_LIST) {
             tokens.emplace_back(TokenKind::CLOSE_PAREN);
             return;
           } else {
             tokens.emplace_back(TokenKind::WHITESPACE);
           }
-        } else { // not a proper list!
+        } else {  // not a proper list!
           tokens.emplace_back(TokenKind::DOT);
           tokens.emplace_back(TokenKind::WHITESPACE);
           toPrint->toTokenList(tokens);
@@ -104,8 +103,7 @@ void Form::toTokenList(std::vector<FormToken> &tokens) {
           return;
         }
       }
-    }
-      break;
+    } break;
     case FormKind::EMPTY_LIST:
       tokens.emplace_back(TokenKind::EMPTY_PAIR);
       break;
@@ -123,25 +121,25 @@ void Form::toTokenList(std::vector<FormToken> &tokens) {
  * Linked list node representing a token in the output (whitespace, paren, newline, etc)
  */
 struct PrettyPrinterNode {
-  FormToken* tok = nullptr; // if we aren't a newline, we will have a token.
-  int line = -1;            // line that token occurs on. undef for newlines
-  int lineIndent = -1;      // indent of line.  only valid for first token in the line
-  int offset = -1;          // offset of beginning of token from left margin
+  FormToken* tok = nullptr;  // if we aren't a newline, we will have a token.
+  int line = -1;             // line that token occurs on. undef for newlines
+  int lineIndent = -1;       // indent of line.  only valid for first token in the line
+  int offset = -1;           // offset of beginning of token from left margin
   int specialIndentDelta = 0;
-  bool is_line_separator = false; // true if line separator (not a token)
-  PrettyPrinterNode *next = nullptr, *prev = nullptr; // linked list
-  PrettyPrinterNode *paren = nullptr; // pointer to open paren if in parens.  open paren points to close and vice versa
-  explicit PrettyPrinterNode(FormToken& _tok) {
-    tok = &_tok;
-  }
+  bool is_line_separator = false;                      // true if line separator (not a token)
+  PrettyPrinterNode *next = nullptr, *prev = nullptr;  // linked list
+  PrettyPrinterNode* paren =
+      nullptr;  // pointer to open paren if in parens.  open paren points to close and vice versa
+  explicit PrettyPrinterNode(FormToken& _tok) { tok = &_tok; }
   PrettyPrinterNode() = default;
 };
 
 /*!
- * Splice in a line break after the given node, it there isn't one already and if it isn't the last node.
+ * Splice in a line break after the given node, it there isn't one already and if it isn't the last
+ * node.
  */
 static void insertNewlineAfter(PrettyPrinterNode* node, int specialIndentDelta) {
-  if(node->next && !node->next->is_line_separator) {
+  if (node->next && !node->next->is_line_separator) {
     auto* nl = new PrettyPrinterNode;
     auto* next = node->next;
     node->next = nl;
@@ -154,10 +152,11 @@ static void insertNewlineAfter(PrettyPrinterNode* node, int specialIndentDelta)
 }
 
 /*!
- * Splice in a line break before the given node, if there isn't one already and if it isn't the first node.
+ * Splice in a line break before the given node, if there isn't one already and if it isn't the
+ * first node.
  */
 static void insertNewlineBefore(PrettyPrinterNode* node, int specialIndentDelta) {
-  if(node->prev && !node->prev->is_line_separator) {
+  if (node->prev && !node->prev->is_line_separator) {
     auto* nl = new PrettyPrinterNode;
     auto* prev = node->prev;
     prev->next = nl;
@@ -178,13 +177,13 @@ static void breakList(PrettyPrinterNode* leftParen) {
   auto* rp = leftParen->paren;
   assert(rp->tok->kind == TokenKind::CLOSE_PAREN);
 
-  for(auto* n = leftParen->next; n && n != rp; n = n->next) {
-    if(!n->is_line_separator) {
-      if(n->tok->kind == TokenKind::OPEN_PAREN) {
+  for (auto* n = leftParen->next; n && n != rp; n = n->next) {
+    if (!n->is_line_separator) {
+      if (n->tok->kind == TokenKind::OPEN_PAREN) {
         n = n->paren;
         assert(n->tok->kind == TokenKind::CLOSE_PAREN);
         insertNewlineAfter(n, 0);
-      } else if(n->tok->kind != TokenKind::WHITESPACE) {
+      } else if (n->tok->kind != TokenKind::WHITESPACE) {
         assert(n->tok->kind != TokenKind::CLOSE_PAREN);
         insertNewlineAfter(n, 0);
       }
@@ -200,19 +199,19 @@ static PrettyPrinterNode* propagatePretty(PrettyPrinterNode* list, int line_leng
   // propagate line numbers
   PrettyPrinterNode* rv = nullptr;
   int line = list->line;
-  for(auto* n = list; n; n = n->next) {
-    if(n->is_line_separator) {
+  for (auto* n = list; n; n = n->next) {
+    if (n->is_line_separator) {
       line++;
     } else {
       n->line = line;
       // add the weird newline.
-      if(n->tok->kind == TokenKind::CLOSE_PAREN) {
-        if(n->line != n->paren->line) {
-          if(n->prev && !n->prev->is_line_separator) {
+      if (n->tok->kind == TokenKind::CLOSE_PAREN) {
+        if (n->line != n->paren->line) {
+          if (n->prev && !n->prev->is_line_separator) {
             insertNewlineBefore(n, 0);
             line++;
           }
-          if(n->next && !n->next->is_line_separator) {
+          if (n->next && !n->next->is_line_separator) {
             insertNewlineAfter(n, 0);
           }
         }
@@ -226,12 +225,12 @@ static PrettyPrinterNode* propagatePretty(PrettyPrinterNode* list, int line_leng
   int offset = 0;
   PrettyPrinterNode* line_start = list;
   bool previous_line_sep = false;
-  for(auto* n = list; n; n = n->next) {
-    if(n->is_line_separator) {
+  for (auto* n = list; n; n = n->next) {
+    if (n->is_line_separator) {
       previous_line_sep = true;
       offset = indentStack.back() += n->specialIndentDelta;
     } else {
-      if(previous_line_sep) {
+      if (previous_line_sep) {
         line_start = n;
         n->lineIndent = offset;
         previous_line_sep = false;
@@ -239,21 +238,20 @@ static PrettyPrinterNode* propagatePretty(PrettyPrinterNode* list, int line_leng
 
       n->offset = offset;
       offset += n->tok->toString().length();
-      if(offset > line_length && !rv) rv = line_start;
-      if(n->tok->kind == TokenKind::OPEN_PAREN) {
-        if(!n->prev || n->prev->is_line_separator) {
+      if (offset > line_length && !rv)
+        rv = line_start;
+      if (n->tok->kind == TokenKind::OPEN_PAREN) {
+        if (!n->prev || n->prev->is_line_separator) {
           indentStack.push_back(offset + 1);
         } else {
           indentStack.push_back(offset - 1);
         }
-
       }
 
-      if(n->tok->kind == TokenKind::CLOSE_PAREN) {
+      if (n->tok->kind == TokenKind::CLOSE_PAREN) {
         indentStack.pop_back();
       }
     }
-
   }
   return rv;
 }
@@ -264,9 +262,9 @@ static PrettyPrinterNode* propagatePretty(PrettyPrinterNode* list, int line_leng
 static PrettyPrinterNode* getNextLine(PrettyPrinterNode* start) {
   assert(!start->is_line_separator);
   int line = start->line;
-  for(;;) {
-    if(start->is_line_separator || start->line == line) {
-      if(start->next)
+  for (;;) {
+    if (start->is_line_separator || start->line == line) {
+      if (start->next)
         start = start->next;
       else
         return nullptr;
@@ -278,32 +276,37 @@ static PrettyPrinterNode* getNextLine(PrettyPrinterNode* start) {
 }
 
 /*!
- * Get the next open paren on the current line (can start in the middle of line, not inclusive of start)
- * nullptr if there's no open parens on the rest of this line.
+ * Get the next open paren on the current line (can start in the middle of line, not inclusive of
+ * start) nullptr if there's no open parens on the rest of this line.
  */
 static PrettyPrinterNode* getNextListOnLine(PrettyPrinterNode* start) {
   int line = start->line;
   assert(!start->is_line_separator);
-  if(!start->next || start->next->is_line_separator) return nullptr;
+  if (!start->next || start->next->is_line_separator)
+    return nullptr;
   start = start->next;
-  while(!start->is_line_separator && start->line == line) {
-    if(start->tok->kind == TokenKind::OPEN_PAREN) return start;
-    if(!start->next) return nullptr;
+  while (!start->is_line_separator && start->line == line) {
+    if (start->tok->kind == TokenKind::OPEN_PAREN)
+      return start;
+    if (!start->next)
+      return nullptr;
     start = start->next;
   }
   return nullptr;
 }
 
 /*!
- * Get the first open paren on the current line (can start in the middle of line, inclusive of start)
- * nullptr if there's no open parens on the rest of this line
+ * Get the first open paren on the current line (can start in the middle of line, inclusive of
+ * start) nullptr if there's no open parens on the rest of this line
  */
 static PrettyPrinterNode* getFirstListOnLine(PrettyPrinterNode* start) {
   int line = start->line;
   assert(!start->is_line_separator);
-  while(!start->is_line_separator && start->line == line) {
-    if(start->tok->kind == TokenKind::OPEN_PAREN) return start;
-    if(!start->next) return nullptr;
+  while (!start->is_line_separator && start->line == line) {
+    if (start->tok->kind == TokenKind::OPEN_PAREN)
+      return start;
+    if (!start->next)
+      return nullptr;
     start = start->next;
   }
   return nullptr;
@@ -316,19 +319,19 @@ static PrettyPrinterNode* getFirstBadLine(PrettyPrinterNode* start, int line_len
   assert(!start->is_line_separator);
   int currentLine = start->line;
   auto* currentLineNode = start;
-  for(;;) {
-    if(start->is_line_separator) {
+  for (;;) {
+    if (start->is_line_separator) {
       assert(start->next);
       start = start->next;
     } else {
-      if(start->line != currentLine) {
+      if (start->line != currentLine) {
         currentLine = start->line;
         currentLineNode = start;
       }
-      if(start->offset > line_length) {
+      if (start->offset > line_length) {
         return currentLineNode;
       }
-      if(!start->next) {
+      if (!start->next) {
         return nullptr;
       }
       start = start->next;
@@ -344,55 +347,54 @@ static void insertBreaksAsNeeded(PrettyPrinterNode* head, int line_length) {
   PrettyPrinterNode* line_to_start_line_search = head;
 
   // loop over lines
-  for(;;) {
-
+  for (;;) {
     // compute lines as needed
     propagatePretty(head, line_length);
 
     // search for a bad line starting at the last line we fixed
     PrettyPrinterNode* candidate_line = getFirstBadLine(line_to_start_line_search, line_length);
     // if we got the same line we started on, this means we couldn't fix it.
-    if(candidate_line == last_line_complete) {
-      candidate_line = nullptr; // so we say our candidate was bad and try to find another
+    if (candidate_line == last_line_complete) {
+      candidate_line = nullptr;  // so we say our candidate was bad and try to find another
       PrettyPrinterNode* next_line = getNextLine(line_to_start_line_search);
-      if(next_line) {
+      if (next_line) {
         candidate_line = getFirstBadLine(next_line, line_length);
       }
     }
-    if(!candidate_line) break;
+    if (!candidate_line)
+      break;
 
     // okay, we have a line which needs fixing.
     assert(!candidate_line->prev || candidate_line->prev->is_line_separator);
     PrettyPrinterNode* form_to_start = getFirstListOnLine(candidate_line);
-    for(;;) {
-      if(!form_to_start) {
+    for (;;) {
+      if (!form_to_start) {
         printf("pretty printer has failed. Fix the bug or increase the the line length.\n");
         assert(false);
       }
       breakList(form_to_start);
       propagatePretty(head, line_length);
-      if(getFirstBadLine(candidate_line, line_length) != candidate_line) {
+      if (getFirstBadLine(candidate_line, line_length) != candidate_line) {
         break;
       }
 
       form_to_start = getNextListOnLine(form_to_start);
-      if(!form_to_start) break;
-
+      if (!form_to_start)
+        break;
     }
 
-
     last_line_complete = candidate_line;
     line_to_start_line_search = candidate_line;
   }
 }
 
 static void insertSpecialBreaks(PrettyPrinterNode* node) {
-  for(; node; node = node->next) {
-    if(!node->is_line_separator && node->tok->kind == TokenKind::SYMBOL) {
+  for (; node; node = node->next) {
+    if (!node->is_line_separator && node->tok->kind == TokenKind::SYMBOL) {
       std::string& name = *node->tok->str;
-      if(name == "deftype") {
+      if (name == "deftype") {
         auto* parent_type_dec = getNextListOnLine(node);
-        if(parent_type_dec) {
+        if (parent_type_dec) {
           insertNewlineAfter(parent_type_dec->paren, 0);
         }
       }
@@ -415,7 +417,7 @@ std::string Form::toStringPretty(int indent, int line_length) {
   head->offset = 0;
   head->lineIndent = 0;
   int offset = head->tok->toString().length();
-  for(size_t i = 1; i < tokens.size(); i++) {
+  for (size_t i = 1; i < tokens.size(); i++) {
     node->next = new PrettyPrinterNode(tokens[i]);
     node->next->prev = node;
     node = node->next;
@@ -428,10 +430,10 @@ std::string Form::toStringPretty(int indent, int line_length) {
   // attach parens.
   std::vector<PrettyPrinterNode*> parenStack;
   parenStack.push_back(nullptr);
-  for(PrettyPrinterNode* n = head; n; n = n->next) {
-    if(n->tok->kind == TokenKind::OPEN_PAREN) {
+  for (PrettyPrinterNode* n = head; n; n = n->next) {
+    if (n->tok->kind == TokenKind::OPEN_PAREN) {
       parenStack.push_back(n);
-    } else if(n->tok->kind == TokenKind::CLOSE_PAREN) {
+    } else if (n->tok->kind == TokenKind::CLOSE_PAREN) {
       n->paren = parenStack.back();
       parenStack.back()->paren = n;
       parenStack.pop_back();
@@ -446,31 +448,31 @@ std::string Form::toStringPretty(int indent, int line_length) {
   propagatePretty(head, line_length);
   insertBreaksAsNeeded(head, line_length);
 
-
   // write to string
   bool newline_prev = true;
-  for(PrettyPrinterNode* n = head; n; n = n->next) {
-    if(n->is_line_separator){
+  for (PrettyPrinterNode* n = head; n; n = n->next) {
+    if (n->is_line_separator) {
       pretty.push_back('\n');
       newline_prev = true;
     } else {
-      if(newline_prev) {
+      if (newline_prev) {
         pretty.append(n->lineIndent, ' ');
         newline_prev = false;
-        if(n->tok->kind == TokenKind::WHITESPACE) continue;
+        if (n->tok->kind == TokenKind::WHITESPACE)
+          continue;
       }
       pretty.append(n->tok->toString());
     }
   }
 
-  for(;;) {
-    if(!head) break;
+  for (;;) {
+    if (!head)
+      break;
     auto* next = head->next;
     delete head;
     head = next;
   }
 
-
   return pretty;
 }
 
@@ -497,7 +499,7 @@ std::shared_ptr<Form> buildList(std::shared_ptr<Form>* forms, int count) {
   auto f = std::make_shared<Form>();
   f->kind = FormKind::PAIR;
   f->pair[0] = forms[0];
-  if(count - 1) {
+  if (count - 1) {
     f->pair[1] = buildList(forms + 1, count - 1);
   } else {
     f->pair[1] = gSymbolTable.getEmptyPair();
@@ -507,7 +509,7 @@ std::shared_ptr<Form> buildList(std::shared_ptr<Form>* forms, int count) {
 }
 
 std::shared_ptr<Form> buildList(std::vector<std::shared_ptr<Form>>& forms) {
-  if(forms.empty()) {
+  if (forms.empty()) {
     return gSymbolTable.getEmptyPair();
   }
   return buildList(forms.data(), forms.size());
diff --git a/doc/emitter.md b/doc/emitter.md
new file mode 100644
index 0000000000..c98cc6ea4d
--- /dev/null
+++ b/doc/emitter.md
@@ -0,0 +1,24 @@
+# Emitter
+x86-64 has a lot of instructions.  They are described in Volume 2 of the 5 Volume "Intel® 64 and IA-32 Architectures Software Developer’s Manual". Just this volume alone is over 2000 pages, which would take forever to fully implement.  As a result, we will use only a subset of these instructions.  This the rough plan:
+
+- Most instructions like `add` will only be implemented with `r64 r64` versions.
+- To accomplish something like `add rax, 1`, we will use a temporary register `X`
+  - `mov X, 1`
+  - `add rax, X`
+  - The constant propagation system will be able to provide enough information that we could eventually use `add r64 immX` and similar if needed.
+  - Register allocation should handle the case `(set! x (+ 3 y))` as:
+     - `mov x, 3`
+     - `add x, y`
+  - but `(set! x (+ y 3))`, in cases where `y` is needed after and `x` can't take its place, will become the inefficient
+     - `mov x, y`
+     - `mov rtemp, 3`
+     - `add x, rtemp`
+- Loading constants into registers will be done efficiently, using the same strategy used by modern versions of `gcc` and `clang`.
+- Memory access will be done in the form `mov rdest, [roff + raddr]` where `roff` is the offset register. Doing memory access in this form was found to be much faster in simple benchmark test.
+- Memory access to the stack will have an extra `sub` and more complicated dereference.  GOAL code seems to avoid using the stack in most places, and I suspect the programmers attempted to avoid stack spills.
+  - `mov rdest, rsp` : coloring move for upcoming subtract
+  - `sub rdest, roff` : convert real pointer to GOAL pointer
+  - `mov rdest, [rdest + roff + variable_offset]` : access memory through normal GOAL deref.
+  - Note - we should check that the register allocator gets this right always, and eliminates moves and avoid using a temporary register.
+  - Again, the constant propagation should give use enough information, if we ever want/need to implement a more efficient `mov rdest, [rsp + varaible_offset]` type instructions.
+- Memory access to static data should use `rip` addressing, like `mov rdest, [rip + offset]`. And creating pointers to static data could be `lea rdest, [rip - roff + offset]`
\ No newline at end of file
diff --git a/doc/registers.md b/doc/registers.md
new file mode 100644
index 0000000000..97d5280b8d
--- /dev/null
+++ b/doc/registers.md
@@ -0,0 +1,111 @@
+## Registers
+Although modern computers are much faster than the PS2, and we could probably get away with a really inefficient register allocation scheme, I think it's worth it to get this right.
+
+
+## Register differences between MIPS and x86-64
+The PS2's MIPS processor has these categories of register:
+- General Purpose. They are 128-bit, but usually only lower 64 bits are used. 32 registers, each 128-bits.
+- Floating point registers. 32 registers, each for a 32-bit float.
+- Vector float registers. 32 registers, each for 4x 32-bit floats. Used only in inline assembly
+- `vi` registers. 16 registers, each a 16-bit integer. Used very rarely in inline assembly
+
+There are also some control/special registers too (`Q`, `R`...), but code using these will be manually ported.
+
+In comparison, x86-64 has much fewer registers:
+- 16 General Purpose. Each 64-bits
+- 16 `xmm` registers. 128-bits, and can store either 128-bit integers or 4x 32-bit floats
+
+Here is the mapping:
+- MIPS GPR (lower 64 bits only) - x86-64 GPR
+- MIPS GPR (128-bits, only special cases) - x64-64 `xmm`
+- MIPS floating point - x64-64 `xmm` (lower 32-bits)
+- MIPS vector float - x64-64 `xmm` (packed single)
+- MIPS `vi` - manually handled??
+
+Here is the MIPS GPR map
+- `r0` or `zero` : always zero
+- `r1` or `at`: assembler temporary, not saved, not used by compiler
+- `r2` or `v0`: return value, not saved
+- `r3` or `v1`: not saved
+- `r4` or `a0`: not saved, argument 0
+- `r5` or `a1`: not saved, argument 1
+- `r6` or `a2`: not saved, argument 2
+- `r7` or `a3`: not saved, argument 3
+- `r8` or `t0`: not saved, argument 4
+- `r9` or `t1`: not saved, argument 5
+- `r10` or `t2`: not saved, argument 6
+- `r11` or `t3`: not saved, argument 7
+- `r12` or `t4`: not saved
+- `r13` or `t5`: not saved
+- `r14` or `t6`: not saved
+- `r15` or `t7`: not saved
+- `r16` or `s0`: saved
+- `r17` or `s1`: saved
+- `r18` or `s2`: saved
+- `r19` or `s3`: saved
+- `r20` or `s4`: saved
+- `r21` or `s5`: saved
+- `r22` or `s6`: saved, process pointer
+- `r23` or `s7`: saved, symbol pointer
+- `r24` or `t8`: not saved
+- `r25` or `t9`: function call pointer
+- `r26` or `k0`: kernel reserved (unused)
+- `r27` or `k1`: kernel reserved (unused)
+- `r28` or `gp`: saved
+- `r29` or `sp`: stack pointer
+- `r30` or `fp`: current function pointer
+- `r31` or `ra`: return address pointer
+
+
+And the x86-64 GPR map
+- `rax`: return value
+- `rcx`: argument 3
+- `rdx`: argument 2
+- `rbx`: saved
+- `rsp`: stack pointer
+- `rbp`: saved
+- `rsi`: argument 1
+- `rdi`: argument 0
+- `r8`: argument 4
+- `r9`: argument 5
+- `r10`: argument 6, saved if not argument
+- `r11`: argument 7, saved if not argument
+- `r12`: saved
+- `r13`: process pointer
+- `r14`: symbol table
+- `r15`: offset pointer
+
+
+### Plan for Memory Access
+The PS2 uses 32-bit pointers, and changing the pointer size is likely to introduce bugs, so we will keep using 32-bit pointers.  Also, GOAL has some hardcoded checks on the value for pointers, so we need to make sure the memory appears to the program at the correct address.
+
+To do this, we have separate "GOAL Pointers" and "real pointers".  The "real pointers" are just normal x86-64 pointers, and the "GOAL Pointer" is an offset into a main memory array.  A "real pointer" to the main memory array is stored in `r15` (offset pointer) when GOAL code is executing, and the GOAL compiler will automatically add this to all memory accesses.
+
+The overhead from doing this is not as bad as you might expect - x86 has nice addressing modes (Scale Index Base) which are quite fast, and don't require the use of temporary registers. If this does turn out to be much slower than I expect, we can introduce the concept of real pointers in GOAL code, and use them in places where we are limited in accessing memory.
+
+The main RAM is mapped at `0x0` on the PS2, with the first 1 MB reserved for the kernel.  We should make sure that the first 1 MB of GOAL main memory will cause a segfault if read/written/executed, to catch null pointer bugs.
+
+In the C Kernel code, the `r15` pointer doesn't exist. Instead, `g_ee_main_memory` is a global which points to the beginning of GOAL main memory.  The `Ptr<T>` template class takes care of converting GOAL and C++ pointers in a convenient way, and catches null pointer access.
+
+The GOAL stack pointer should likely be a real pointer, for performance reasons.  This makes pushing/popping/calling/returning/accessing stack variables much faster, with the only cost being getting a GOAL stack pointer requiring some extra work. The stack pointer's value is read/written extremely rarely, so this seems like a good tradeoff.
+
+The other registers are less clear.  The process pointer can probably be a real pointer.  But the symbol table could go a few ways:
+1. Make it a real pointer.  Symbol value access is fast, but comparison against false requires two extra operations.
+2. Make it a GOAL pointer. Symbol value access requires more complicated addressing modes, but comparison against false is fast.
+
+Right now I'm leaning toward 1, but making it a configurable option in case I'm wrong. It should only be a change in a few places (emitter + where it's set up in the runtime).
+
+### Plan for Function Call and Arguments
+In GOAL for MIPS, function calls are weird.  Functions are always called by register using `t9`. There seems to be a different register allocator for function pointers, as nested function calls have really wacky register allocation.  In GOAL-x86-64, this restriction will be removed, and a function can be called from any register. (see next section for why we can do this)
+
+Unfortunately, GOAL's 128-bit function arguments present a big challenge.  When calling a function, we can't know if the function we're calling is expecting an integer, float, or 128-bit integer. In fact, the caller may not even know if it has an integer, float, or 128-bit integer. The easy and foolproof way to get this right is to use 128-bit `xmm` registers for all arguments and return values, but this will cause a massive performance hit and increase code size, as we'll have to move values between register types constantly. The current plan is this:
+
+- Floats go in GPRs for arguments/return values. GOAL does this too, and takes the hit of converting between registers as well. Probably the impact on a modern CPU is even worse, but we can live with it.
+- We'll compromise 
+
+
+### Plan for Static Data
+
+### Plan for Memory
+
+### Other details
diff --git a/doc/type_system.md b/doc/type_system.md
index bbc7a5a2e2..50d87924c0 100644
--- a/doc/type_system.md
+++ b/doc/type_system.md
@@ -6,7 +6,7 @@ This document explains the GOAL type system.  The GOAL type system supports runt
   
   Some objects have runtime type information, and others don't.  Objects which have runtime type information can have their type identified at runtime, and are called "boxed objects".  Objects without runtime type information are called "unboxed objects".  An unboxed object cannot reliably be detected as a unboxed object - you can't write a function that takes an arbitrary object and tells you if its boxed or not.  However, boxed objects can always be recognized as boxed.
   
-  All types have a parent type, and all types descend from the parent type `object`, except for the special type `none`. The `none` type doesn't exist in the runtime and is used to represent an invalid value that the compiler should not use.  For example, the return type of a function which doesn't return anything is `none`, and attempting to use this value should cause an error.
+  All types have a parent type, and all types descend from the parent type `object`, except for the special type `none` (and maybe `_type_`, but more on this later). The `none` type doesn't exist in the runtime and is used to represent an invalid value that the compiler should not use.  For example, the return type of a function which doesn't return anything is `none`, and attempting to use this value should cause an error.
   
   Here are some important special types:
   - `object` - the parent of all types
@@ -15,7 +15,7 @@ This document explains the GOAL type system.  The GOAL type system supports runt
   
   All types have methods. Objects have access to all of their parents methods, and may override parent methods.  All types have these 9 methods:
   
-  - `new` - like a constructor, returns a new object.  It's not used in all cases, and on all types, and needs more documentation.
+  - `new` - like a constructor, returns a new object.  It's not used in all cases, and on all types, and needs more documentation on when specifically it is used.
   - `delete` - basically unused, but like a destructor.  Often calls `kfree`, which does nothing.
   - `print` - prints a short, one line representation of the object to the `PrintBuffer`
   - `inspect` - prints a multi-line description of the object to the `PrintBuffer`. Usually auto-generated by the compiler and prints out the name and value of each field.
@@ -25,7 +25,7 @@ This document explains the GOAL type system.  The GOAL type system supports runt
   - `relocate` - Some GOAL objects will be moved in memory by the kernel as part of the compacting actor heap system. After being moved, the `relocate` method will be called with the offset of the move, and the object should fix up any internal pointers which may point to the old location. It's also called on v2 objects loaded by the linker when they are first loaded into memory.
   - `memusage` - Not understood yet, but probably returns how much memory in bytes the object uses. Not supported by all objects.
   
-Usually a method which overrides a parent method will have the same argument and return types.  The only exception is `new` methods, which can have different argument/return types from the parent.
+Usually a method which overrides a parent method must have the same argument and return types.  The only exception is `new` methods, which can have different argument/return types from the parent.  (Dee the later section on `_type_` for another exception)
   
 The compiler's implementation for calling a method is:
 - Is the type a basic?
@@ -118,9 +118,8 @@ There's a single type system library, located in `common/type_system`.  It will
  The main features are:
 
 - `TypeSystem` stores all type information and provides a convenient way to add new types or request information about existing types.
-- `Type` a GOAL Type.  A `Type` is identified by a single unique string. Examples: `function`, `string`, `vector3h`.
+- `Type` information about a GOAL Type.  A "base GOAL type" is identified by a single unique string. Examples: `function`, `string`, `vector3h`.
 - `TypeSpec` a way to specify either `Type` or a "compound type".  Compound types are used to create types which represent specific function types (function which takes two integer arguments and returns a string), or specific pointer/array types (pointer to an integer).  These can be represented as (possibly nested) lists, like `(pointer integer)` or `(function (integer integer) string)`.
-- `FunctionSpec` (unimplemented) - contains a `TypeSpec` plus some additional information about a function (like if it is a global function, a method, names of the arguments, etc)
 - Type Checking for compiler
 - Parsing of type definitions for compiler
 - Lowest common ancestor implementation for compiler to figure out return types for branching forms.
@@ -187,33 +186,14 @@ Method System
 All type definitions should also define all the methods, in the order they appear in the vtable.  I suspect GOAL had this as well because the method ordering otherwise seems random, and in some cases impossible to get right unless (at least) the number of methods was specified in the type declaration.
 
 
-
 Todo
----------
-- [x] Difference between "runtime" and "compile time" types?
-    - [ ] `inline-array` and `pointer`
-- [x] Arrays which aren't `array`s and aren't fields.
-- [x] `lookup_field_info` (returning the correct field type for arrays/dynamics, info about how to deref)
-- [x] `deref_info`
-- [ ] Finish builtin types
-- [ ] Tests for...
-  - [ ] Builtin types
-  - [ ] Methods
-  - [ ] Multiple definition checks
-  - [ ] Deref
-  - [ ] Array access
-  - [ ] Field creation
-- [ ] Support for `_type_` / method specific stuff. (maybe this should live outside the type system?)
-- [ ] Ability to export type in `deftype` form.
-- [x] Multiple definition checks
-- [ ] Reverse field (offset/deref to fields)
-- [ ] Type Checking
-- [ ] Function Specs
-- [ ] Lowest Common Ancestor
-- [x] Document `:inline`, `:dynamic:` and field arrays.
-- [x] Document alignment rules
-- [ ] Structure type with itself as a field
-- [ ] Ability to read a `deftype` form.
-  - [ ] In the decompiler
-  - [ ] In the compiler, with the ability to do constant propagation and put things like `(+ 1 2)` or `MY_CONSTANT` as compile-time array size constants by providing a function evaluating an `Object` to an `int`.
-- [ ] Bitfield types
\ No newline at end of file
+-----
+- [ ] Kernel types that are built-in
+- [ ] Signed/unsigned for a few built-in type fields
+- [ ] Tests for field placement logic (probably a full compiler test?)
+- [ ] Bitfield types
+- [ ] Type redefinition tests (these are a pain and probably useless, might just wait for full compiler tests?)
+- [ ] Stuff for decompiler
+  - [ ] What field is here?
+  - [ ] Export all deftypes
+  
\ No newline at end of file
diff --git a/game/kernel/fileio.cpp b/game/kernel/fileio.cpp
index 585748bf0d..c5ccbb3e43 100644
--- a/game/kernel/fileio.cpp
+++ b/game/kernel/fileio.cpp
@@ -199,6 +199,7 @@ char* basename_goal(char* s) {
     }
   }
 
+  /* Original code, has memory bug.
   // back up...
   for (;;) {
     if (pt < input) {
@@ -211,6 +212,20 @@ char* basename_goal(char* s) {
       return pt + 1;              // and return one past
     }
   }
+   */
+
+  // back up...
+  for (;;) {
+    if (pt <= input) {
+      return input;
+    }
+    pt--;
+    char c = *pt;
+    // until we hit a slash.
+    if (c == '\\' || c == '/') {  // slashes
+      return pt + 1;              // and return one past
+    }
+  }
 }
 
 /*!
diff --git a/game/kernel/klink.cpp b/game/kernel/klink.cpp
index 38eba8ee74..5978131404 100644
--- a/game/kernel/klink.cpp
+++ b/game/kernel/klink.cpp
@@ -14,6 +14,7 @@
 #include "kboot.h"
 #include "kprint.h"
 #include "common/symbols.h"
+#include "common/goal_constants.h"
 
 namespace {
 // turn on printf's for debugging linking issues.
diff --git a/game/kernel/kmemcard.h b/game/kernel/kmemcard.h
index 59738a098e..2ac954bb82 100644
--- a/game/kernel/kmemcard.h
+++ b/game/kernel/kmemcard.h
@@ -3,7 +3,6 @@
  * Memory card interfaces. Very messy code.
  */
 
-
 #ifndef JAK_KMEMCARD_H
 #define JAK_KMEMCARD_H
 
diff --git a/game/kernel/kprint.cpp b/game/kernel/kprint.cpp
index 59b086a667..0fde516a49 100644
--- a/game/kernel/kprint.cpp
+++ b/game/kernel/kprint.cpp
@@ -8,6 +8,7 @@
 #include <stdarg.h>
 #include <stdio.h>
 
+#include "common/goal_constants.h"
 #include "common/common_types.h"
 #include "kprint.h"
 #include "kmachine.h"
@@ -880,7 +881,7 @@ s32 format_impl(uint64_t* args) {
             if (sym.offset) {
               Ptr<Type> type = *sym.cast<Ptr<Type>>();
               if (type.offset) {
-                call_method_of_type(in, type, GOAL_PRINT_FUNC);
+                call_method_of_type(in, type, GOAL_PRINT_METHOD);
               }
             } else {
               throw std::runtime_error("failed to find symbol in format!");
@@ -901,7 +902,7 @@ s32 format_impl(uint64_t* args) {
             if (sym.offset) {
               Ptr<Type> type = *sym.cast<Ptr<Type>>();
               if (type.offset) {
-                call_method_of_type(in, type, GOAL_INSPECT_FUNC);
+                call_method_of_type(in, type, GOAL_INSPECT_METHOD);
               }
             } else {
               throw std::runtime_error("failed to find symbol in format!");
diff --git a/game/kernel/kscheme.cpp b/game/kernel/kscheme.cpp
index d5f569dc8d..af98ad8422 100644
--- a/game/kernel/kscheme.cpp
+++ b/game/kernel/kscheme.cpp
@@ -18,6 +18,7 @@
 #include "klink.h"
 #include "common/symbols.h"
 #include "common/versions.h"
+#include "common/goal_constants.h"
 
 //! Controls link mode when EnableMethodSet = 0, MasterDebug = 1, DiskBoot = 0. Will enable a
 //! warning message if EnableMethodSet = 1
@@ -1009,7 +1010,7 @@ u64 print_object(u32 obj) {
     } else if ((obj & OFFSET_MASK) == PAIR_OFFSET) {
       return print_pair(obj);
     } else if ((obj & OFFSET_MASK) == BASIC_OFFSET) {
-      return call_method_of_type(obj, Ptr<Type>(*Ptr<u32>(obj - 4)), GOAL_PRINT_FUNC);
+      return call_method_of_type(obj, Ptr<Type>(*Ptr<u32>(obj - 4)), GOAL_PRINT_METHOD);
     } else {
       cprintf("#<unknown type %d @ #x%x>", obj & OFFSET_MASK, obj);
     }
@@ -1217,7 +1218,7 @@ u64 copy_structure(u32 it, u32 unknown) {
 u64 copy_basic(u32 obj, u32 heap) {
   // determine size of basic. We call a method instead of using asize_of_basic in case the type has
   // overridden the default asize_of method.
-  u32 size = call_method_of_type(obj, Ptr<Type>(*Ptr<u32>(obj - BASIC_OFFSET)), GOAL_ASIZE_FUNC);
+  u32 size = call_method_of_type(obj, Ptr<Type>(*Ptr<u32>(obj - BASIC_OFFSET)), GOAL_ASIZE_METHOD);
   u32 result;
 
   if (*Ptr<u32>(heap - 4) == *(s7 + FIX_SYM_SYMBOL_TYPE)) {
@@ -1247,7 +1248,8 @@ u64 inspect_object(u32 obj) {
     } else if ((obj & OFFSET_MASK) == PAIR_OFFSET) {
       return inspect_pair(obj);
     } else if ((obj & OFFSET_MASK) == BASIC_OFFSET) {
-      return call_method_of_type(obj, Ptr<Type>(*Ptr<u32>(obj - BASIC_OFFSET)), GOAL_INSPECT_FUNC);
+      return call_method_of_type(obj, Ptr<Type>(*Ptr<u32>(obj - BASIC_OFFSET)),
+                                 GOAL_INSPECT_METHOD);
     } else {
       cprintf("#<unknown type %d @ #x%x>", obj & OFFSET_MASK, obj);
     }
diff --git a/game/kernel/kscheme.h b/game/kernel/kscheme.h
index 38c8df351d..5fa1bbf33e 100644
--- a/game/kernel/kscheme.h
+++ b/game/kernel/kscheme.h
@@ -18,23 +18,12 @@ extern Ptr<u32> SymbolTable2;
 extern Ptr<u32> LastSymbol;
 
 constexpr s32 GOAL_MAX_SYMBOLS = 0x2000;
-constexpr s32 BINTEGER_OFFSET = 0;
-constexpr s32 PAIR_OFFSET = 2;
-constexpr s32 BASIC_OFFSET = 4;
+
 constexpr s32 SYM_INFO_OFFSET = 0xff34;
 constexpr u32 EMPTY_HASH = 0x8454B6E6;
 constexpr u32 OFFSET_MASK = 7;
 constexpr u32 CRC_POLY = 0x04c11db7;
 
-constexpr u32 GOAL_NEW_FUNC = 0;      // method ID of GOAL new
-constexpr u32 GOAL_DEL_FUNC = 1;      // method ID of GOAL delete
-constexpr u32 GOAL_PRINT_FUNC = 2;    // method ID of GOAL print
-constexpr u32 GOAL_INSPECT_FUNC = 3;  // method ID of GOAL inspect
-constexpr u32 GOAL_LENGTH_FUNC = 4;   // method ID of GOAL length
-constexpr u32 GOAL_ASIZE_FUNC = 5;    // method ID of GOAL size
-constexpr u32 GOAL_COPY_FUNC = 6;     // method ID of GOAL copy
-constexpr u32 GOAL_RELOC_FUNC = 7;    // method ID of GOAL relocate
-
 constexpr u32 DEFAULT_METHOD_COUNT = 12;
 constexpr u32 FALLBACK_UNKNOWN_METHOD_COUNT = 44;
 
diff --git a/game/main.cpp b/game/main.cpp
index 442d7ad213..c0a1fc30fc 100644
--- a/game/main.cpp
+++ b/game/main.cpp
@@ -7,7 +7,7 @@
 #include "common/versions.h"
 
 int main(int argc, char** argv) {
-  while(true) {
+  while (true) {
     // run the runtime in a loop so we can reset the game and have it restart cleanly
     printf("gk %d.%d\n", versions::GOAL_VERSION_MAJOR, versions::GOAL_VERSION_MINOR);
     exec_runtime(argc, argv);
diff --git a/game/overlord/dma.cpp b/game/overlord/dma.cpp
index 738ba1f988..4cbc30f65e 100644
--- a/game/overlord/dma.cpp
+++ b/game/overlord/dma.cpp
@@ -76,7 +76,7 @@ void DMA_SendToEE(void* data, u32 size, void* dest) {
 
   if (dmaid == 0) {
     do {
-      printf("Got a bad DMA ID!\n"); // added
+      printf("Got a bad DMA ID!\n");  // added
     } while (true);
   }
 }
diff --git a/game/overlord/fake_iso.cpp b/game/overlord/fake_iso.cpp
index 8de67e0b7d..cccc27025a 100644
--- a/game/overlord/fake_iso.cpp
+++ b/game/overlord/fake_iso.cpp
@@ -79,20 +79,16 @@ static const char* next_dir = nullptr;
  */
 int FS_Init(u8* buffer) {
   (void)buffer;
-  // get path to next/. Will be set in the gk.sh launch script. This is for Linux only
-
-  /*
-   next_dir = std::getenv("NEXT_DIR"); // todo windows?
-
+  // get path to next/. Will be set in the gk.sh launch script.
+  next_dir = std::getenv("NEXT_DIR");
   assert(next_dir);
 
   // get path to next/data/fake_iso.txt, the map file.
   char fakeiso_path[512];
   strcpy(fakeiso_path, next_dir);
-  strcat(fakeiso_path, "/game/fake_iso.txt"); // todo windows paths?
-  */
-  char fakeiso_path[] = "C:\\Users\\Shalen\\Documents\\GitHub\\jak-project-windows-proj\\game\\fake_iso.txt";
-  char NEXT_DIR[] = "C:\\Users\\Shalen\\Documents\\GitHub\\jak-project-windows-proj";
+  fake_iso_path = std::getenv("FAKE_ISO_PATH");  
+  assert(fake_iso_path);
+  strcat(fakeiso_path, fake_iso_path);
 
   // open the map.
   FILE* fp = fopen(fakeiso_path, "r");
@@ -330,7 +326,7 @@ uint32_t FS_BeginRead(LoadStackEntry* fd, void* buffer, int32_t len) {
  */
 uint32_t FS_SyncRead() {
   // FS_BeginRead is blocking, so this is useless.
-  if(read_in_progress) {
+  if (read_in_progress) {
     read_in_progress = false;
     return CMD_STATUS_IN_PROGRESS;
   } else {
diff --git a/game/overlord/fake_iso.h b/game/overlord/fake_iso.h
index fcd7013106..a120484ada 100644
--- a/game/overlord/fake_iso.h
+++ b/game/overlord/fake_iso.h
@@ -17,4 +17,4 @@
 void fake_iso_init_globals();
 extern IsoFs fake_iso;
 
-#endif //JAK_V2_FAKE_ISO_H
+#endif  // JAK_V2_FAKE_ISO_H
diff --git a/game/overlord/iso.cpp b/game/overlord/iso.cpp
index e482a174d7..b374e3388e 100644
--- a/game/overlord/iso.cpp
+++ b/game/overlord/iso.cpp
@@ -767,7 +767,6 @@ u32 ProcessVAGData(IsoMessage* _cmd, IsoBufferHeader* buffer_header) {
 // TODO - UpdatePlayPos
 // TODO - CheckVAGStreamProgress
 
-
 void* RPC_DGO(unsigned int fno, void* _cmd, int y);
 void LoadDGO(RPC_Dgo_Cmd* cmd);
 void LoadNextDGO(RPC_Dgo_Cmd* cmd);
@@ -913,7 +912,7 @@ void CancelDGO(RPC_Dgo_Cmd* cmd) {
     SendMbx(sync_mbx, nullptr);
     // wait for it to abort.
     WaitMbx(dgo_mbx);
-    assert(cmd); // bug
+    assert(cmd);  // bug
     cmd->result = DGO_RPC_RESULT_ABORTED;
     scmd.cmd_id = 0;
   }
diff --git a/game/overlord/iso_api.cpp b/game/overlord/iso_api.cpp
index 654e6a943b..1ff89e3296 100644
--- a/game/overlord/iso_api.cpp
+++ b/game/overlord/iso_api.cpp
@@ -6,7 +6,7 @@ using namespace iop;
 /*!
  * Load a File to IOP memory (blocking)
  */
-void LoadISOFileToIOP(FileRecord *file, void *addr, uint32_t length) {
+void LoadISOFileToIOP(FileRecord* file, void* addr, uint32_t length) {
   printf("[OVERLORD] LoadISOFileToIOP %s, %d/%d bytes\n", file->name, length, file->size);
   IsoCommandLoadSingle cmd;
   cmd.cmd_id = LOAD_TO_IOP_CMD_ID;
@@ -18,7 +18,7 @@ void LoadISOFileToIOP(FileRecord *file, void *addr, uint32_t length) {
   SendMbx(iso_mbx, &cmd);
   SleepThread();
 
-  if(cmd.status) {
+  if (cmd.status) {
     cmd.length_to_copy = 0;
   }
 }
@@ -26,7 +26,7 @@ void LoadISOFileToIOP(FileRecord *file, void *addr, uint32_t length) {
 /*!
  * Load a File to IOP memory (blocking)
  */
-void LoadISOFileToEE(FileRecord *file, uint32_t addr, uint32_t length) {
+void LoadISOFileToEE(FileRecord* file, uint32_t addr, uint32_t length) {
   printf("[OVERLORD] LoadISOFileToEE %s, %d/%d bytes\n", file->name, length, file->size);
   IsoCommandLoadSingle cmd;
   cmd.cmd_id = LOAD_TO_EE_CMD_ID;
@@ -38,7 +38,7 @@ void LoadISOFileToEE(FileRecord *file, uint32_t addr, uint32_t length) {
   SendMbx(iso_mbx, &cmd);
   SleepThread();
 
-  if(cmd.status) {
+  if (cmd.status) {
     cmd.length_to_copy = 0;
   }
 }
\ No newline at end of file
diff --git a/game/overlord/iso_api.h b/game/overlord/iso_api.h
index 0b07591e4a..f3255f9214 100644
--- a/game/overlord/iso_api.h
+++ b/game/overlord/iso_api.h
@@ -2,7 +2,7 @@
 #define JAK_V2_ISO_API_H
 #include "isocommon.h"
 
-void LoadISOFileToIOP(FileRecord *file, void *addr, uint32_t length);
-void LoadISOFileToEE(FileRecord *file, uint32_t ee_addr, uint32_t length);
+void LoadISOFileToIOP(FileRecord* file, void* addr, uint32_t length);
+void LoadISOFileToEE(FileRecord* file, uint32_t ee_addr, uint32_t length);
 
-#endif //JAK_V2_ISO_API_H
+#endif  // JAK_V2_ISO_API_H
diff --git a/game/overlord/iso_queue.cpp b/game/overlord/iso_queue.cpp
index a2aa7acc00..9804776522 100644
--- a/game/overlord/iso_queue.cpp
+++ b/game/overlord/iso_queue.cpp
@@ -21,7 +21,6 @@ struct IsoStrBuffer {
   u8 data[STR_BUFFER_DATA_SIZE];
 };
 
-
 static IsoBuffer sBuffer[N_BUFFERS];
 static IsoStrBuffer sStrBuffer[N_STR_BUFFERS];
 static IsoBuffer* sFreeBuffer;
@@ -36,7 +35,7 @@ VagCommand vag_cmds[N_VAG_CMDS];
 static s32 sSema;
 
 IsoBufferHeader* TryAllocateBuffer(uint32_t size);
-void ReleaseMessage(IsoMessage *cmd);
+void ReleaseMessage(IsoMessage* cmd);
 void FreeVAGCommand(VagCommand* cmd);
 
 void iso_queue_init_globals() {
@@ -44,7 +43,8 @@ void iso_queue_init_globals() {
   memset(sStrBuffer, 0, sizeof(sStrBuffer));
   sFreeBuffer = nullptr;
   sFreeStrBuffer = nullptr;
-  for(auto& e : gPriStack) e.reset();
+  for (auto& e : gPriStack)
+    e.reset();
 
   vag_cmd_cnt = 0;
   vag_cmd_used = 0;
@@ -54,25 +54,25 @@ void iso_queue_init_globals() {
 }
 
 void PriStackEntry::reset() {
-  for(auto& c : cmds) c = nullptr;
+  for (auto& c : cmds)
+    c = nullptr;
   n = 0;
-  for(auto& x : names) x.clear();
+  for (auto& x : names)
+    x.clear();
 }
 
-
 void InitBuffers() {
-
   // chain all buffers together and set them as free.
-  for(uint32_t i = 0; i < N_BUFFERS; i++) {
+  for (uint32_t i = 0; i < N_BUFFERS; i++) {
     sBuffer[i].header.data = nullptr;
     sBuffer[i].header.data_size = 0;
     sBuffer[i].header.buffer_size = BUFFER_PAGE_SIZE;
-    sBuffer[i].header.next = &sBuffer[i+1].header;
+    sBuffer[i].header.next = &sBuffer[i + 1].header;
   }
   sBuffer[N_BUFFERS - 1].header.next = nullptr;
   sFreeBuffer = &sBuffer[0];
 
-  for(uint32_t i = 0; i < N_STR_BUFFERS; i++) {
+  for (uint32_t i = 0; i < N_STR_BUFFERS; i++) {
     sStrBuffer[i].header.data = nullptr;
     sStrBuffer[i].header.data_size = 0;
     sStrBuffer[i].header.buffer_size = STR_BUFFER_DATA_SIZE;
@@ -89,19 +89,20 @@ void InitBuffers() {
   params.init_count = 0;
   sSema = CreateSema(&params);
 
-  if(sSema < 0) {
-    for(;;) {
+  if (sSema < 0) {
+    for (;;) {
       printf("[OVERLORD] VAG Semaphore creation failed!\n");
     }
   }
 }
 
 /*!
- * Allocate a buffer of the given size. If not possible, loop forever. Size must be BUFFER_PAGE_SIZE or STR_BUFFER_DATA_SIZE,
+ * Allocate a buffer of the given size. If not possible, loop forever. Size must be BUFFER_PAGE_SIZE
+ * or STR_BUFFER_DATA_SIZE,
  */
 IsoBufferHeader* AllocateBuffer(uint32_t size) {
-  IsoBufferHeader *buffer = TryAllocateBuffer(size);
-  if(buffer) {
+  IsoBufferHeader* buffer = TryAllocateBuffer(size);
+  if (buffer) {
     printf("--------------- allocated buffer size %d\n", size);
     return buffer;
   } else {
@@ -111,17 +112,16 @@ IsoBufferHeader* AllocateBuffer(uint32_t size) {
   }
 }
 
-
 /*!
- * Allocate a buffer of given size.  If the size isn't BUFFER_PAGE_SIZE, you get a streaming buffer (STR_BUFFER_DATA_SIZE).
- * If no allocation can be done, return nullptr.
+ * Allocate a buffer of given size.  If the size isn't BUFFER_PAGE_SIZE, you get a streaming buffer
+ * (STR_BUFFER_DATA_SIZE). If no allocation can be done, return nullptr.
  */
 IsoBufferHeader* TryAllocateBuffer(uint32_t size) {
   IsoStrBuffer* top_str = sFreeStrBuffer;
   IsoBuffer* top_buff = sFreeBuffer;
 
-  if(size == BUFFER_PAGE_SIZE) {
-    if(sFreeBuffer) {
+  if (size == BUFFER_PAGE_SIZE) {
+    if (sFreeBuffer) {
       auto next = sFreeBuffer->header.next;
       sFreeBuffer->header.data = nullptr;
       sFreeBuffer = (IsoBuffer*)next;
@@ -130,7 +130,7 @@ IsoBufferHeader* TryAllocateBuffer(uint32_t size) {
       return (IsoBufferHeader*)top_buff;
     }
   } else {
-    if(sFreeStrBuffer) {
+    if (sFreeStrBuffer) {
       auto next = sFreeStrBuffer->header.next;
       sFreeStrBuffer->header.data = nullptr;
       sFreeStrBuffer = (IsoStrBuffer*)next;
@@ -146,10 +146,10 @@ IsoBufferHeader* TryAllocateBuffer(uint32_t size) {
 /*!
  * Return a buffer once you are done using it so somebody else can have a turn
  */
-void FreeBuffer(IsoBufferHeader *buffer) {
+void FreeBuffer(IsoBufferHeader* buffer) {
   IsoBufferHeader* b = (IsoBufferHeader*)buffer;
   printf("--------------- free buffer size %d\n", b->buffer_size);
-  if(b->buffer_size == BUFFER_PAGE_SIZE) {
+  if (b->buffer_size == BUFFER_PAGE_SIZE) {
     b->next = sFreeBuffer;
     sFreeBuffer = (IsoBuffer*)b;
   } else {
@@ -163,8 +163,8 @@ void FreeBuffer(IsoBufferHeader *buffer) {
  * The actual function does nothing.
  */
 void DisplayQueue() {
-  for(int pri = 0; pri < N_PRIORITIES; pri++) {
-    for(int cmd = 0; cmd < (int)gPriStack[pri].n; cmd++) {
+  for (int pri = 0; pri < N_PRIORITIES; pri++) {
+    for (int cmd = 0; cmd < (int)gPriStack[pri].n; cmd++) {
       printf("  PRI %d elt %d %s\n", pri, cmd, gPriStack[pri].names[cmd].c_str());
     }
   }
@@ -175,13 +175,14 @@ void DisplayQueue() {
  * If there is no room left in the queue, ReturnMessage with a CMD_STATUS_FAILED_TO_QUEUE.
  * Return 1 on success.
  */
-u32 QueueMessage(IsoMessage *cmd, int32_t priority, const char *name) {
+u32 QueueMessage(IsoMessage* cmd, int32_t priority, const char* name) {
   u32 ok = gPriStack[priority].n != PRI_STACK_LENGTH;
-  if(ok) {
+  if (ok) {
     gPriStack[priority].cmds[gPriStack[priority].n] = cmd;
     gPriStack[priority].names[gPriStack[priority].n] = name;
     gPriStack[priority].n++;
-    printf("[OVERLORD] Queue %d (%d/%d), %s\n", priority, gPriStack[priority].n, PRI_STACK_LENGTH, gPriStack[priority].names[gPriStack[priority].n - 1].c_str());
+    printf("[OVERLORD] Queue %d (%d/%d), %s\n", priority, gPriStack[priority].n, PRI_STACK_LENGTH,
+           gPriStack[priority].names[gPriStack[priority].n - 1].c_str());
     DisplayQueue();
   } else {
     printf("[OVERLORD ISO QUEUE] Failed to queue!\n");
@@ -194,31 +195,31 @@ u32 QueueMessage(IsoMessage *cmd, int32_t priority, const char *name) {
 /*!
  * Remove a message from the priority stack.
  */
-void UnqueueMessage(IsoMessage *cmd) {
+void UnqueueMessage(IsoMessage* cmd) {
   int pri = 0;
   u32 idx = 0;
   PriStackEntry* pse;
 
   // loop over priorities
-  for(pri = 0; pri < N_PRIORITIES; pri++) {
+  for (pri = 0; pri < N_PRIORITIES; pri++) {
     pse = gPriStack + pri;
 
     // loop over entries
-    for(idx = 0; idx < gPriStack[pri].n; idx++) {
-      if(pse->cmds[idx] == cmd) {
+    for (idx = 0; idx < gPriStack[pri].n; idx++) {
+      if (pse->cmds[idx] == cmd) {
         goto found;
       }
     }
   }
   printf("[OVERLORD ISO QUEUE] Failed to unqueue!\n");
 
-  found:
+found:
   assert(gPriStack[pri].cmds[idx] == cmd);
 
   // pop
   gPriStack[pri].n--;
   // and move other entries up.
-  while(idx < gPriStack[pri].n) {
+  while (idx < gPriStack[pri].n) {
     pse->cmds[idx] = pse->cmds[idx + 1];
     idx++;
   }
@@ -227,33 +228,32 @@ void UnqueueMessage(IsoMessage *cmd) {
 
 /*!
  * Get the highest priority message with an open buffer.
- * (Note - messages with priority less than max priority will be gotten if they have < 2 buffers filled)
+ * (Note - messages with priority less than max priority will be gotten if they have < 2 buffers
+ * filled)
  * @return
  */
 IsoMessage* GetMessage() {
   // loop over all priorities
-  for(int pri = (N_PRIORITIES - 1); pri >= 0; pri--) {
+  for (int pri = (N_PRIORITIES - 1); pri >= 0; pri--) {
     auto pse = gPriStack + pri;
     int idx = gPriStack[pri].n;
-    for(idx = idx - 1; idx >= 0; idx--) {
-      if(pse->cmds[idx]->fd &&
-         pse->cmds[idx]->status == CMD_STATUS_IN_PROGRESS &&
-         pse->cmds[idx]->ready_for_data) {
-        if(pri == N_PRIORITIES - 1) {
+    for (idx = idx - 1; idx >= 0; idx--) {
+      if (pse->cmds[idx]->fd && pse->cmds[idx]->status == CMD_STATUS_IN_PROGRESS &&
+          pse->cmds[idx]->ready_for_data) {
+        if (pri == N_PRIORITIES - 1) {
           // return high priority commands only if they don't have any buffers filled
-          if(!pse->cmds[idx]->callback_buffer) {
+          if (!pse->cmds[idx]->callback_buffer) {
             return pse->cmds[idx];
           }
         } else {
           // return lower priority commands if they don't have 2 buffers filled.
-          if(!pse->cmds[idx]->callback_buffer ||
-             !(IsoBufferHeader*)(pse->cmds[idx]->callback_buffer)->next) {
+          if (!pse->cmds[idx]->callback_buffer ||
+              !(IsoBufferHeader*)(pse->cmds[idx]->callback_buffer)->next) {
             return pse->cmds[idx];
           }
         }
       }
     }
-
   }
   return nullptr;
 }
@@ -265,21 +265,27 @@ void ProcessMessageData() {
   int32_t pri = N_PRIORITIES - 1;
 
   for (;;) {
-    if (pri < 0) return;
+    if (pri < 0)
+      return;
     int32_t cmdID = gPriStack[pri].n;
-    IsoMessage *popped_command;
+    IsoMessage* popped_command;
     do {
       cmdID--;
-      if (cmdID < 0) goto end_cur;
+      if (cmdID < 0)
+        goto end_cur;
       popped_command = gPriStack[pri].cmds[cmdID];
       auto* callback_buffer = popped_command->callback_buffer;
-      if(popped_command->status == CMD_STATUS_IN_PROGRESS && callback_buffer) { // if we have a callback buffer (meaning a read finished and let us know)
+      if (popped_command->status == CMD_STATUS_IN_PROGRESS &&
+          callback_buffer) {  // if we have a callback buffer (meaning a read finished and let us
+                              // know)
         // execute the callback!
-        uint32_t callback_result = popped_command->callback_function(popped_command, callback_buffer);
+        uint32_t callback_result =
+            popped_command->callback_function(popped_command, callback_buffer);
         popped_command->status = callback_result;
-//        printf("ProcessMessage Data set command %p status to %d\n", popped_command, popped_command->status);
+        //        printf("ProcessMessage Data set command %p status to %d\n", popped_command,
+        //        popped_command->status);
         // if we're done with the buffer, free it and load the next one (if there is one)
-        if(callback_buffer->data_size == 0) {
+        if (callback_buffer->data_size == 0) {
           popped_command->callback_buffer = (IsoBufferHeader*)callback_buffer->next;
           printf("free 1\n");
           FreeBuffer(callback_buffer);
@@ -290,7 +296,7 @@ void ProcessMessageData() {
     ReturnMessage(popped_command);
     // return message todo this will free vag commands!
     pri++;
-    end_cur:
+  end_cur:
     pri--;
   }
 }
@@ -298,9 +304,9 @@ void ProcessMessageData() {
 /*!
  * Wakeup thread/message mbx for a message
  */
-void ReturnMessage(IsoMessage *cmd) {
-  if(!cmd->messagebox_to_reply) {
-    if(cmd->thread_id == 0) {
+void ReturnMessage(IsoMessage* cmd) {
+  if (!cmd->messagebox_to_reply) {
+    if (cmd->thread_id == 0) {
       FreeVAGCommand((VagCommand*)cmd);
     } else {
       WakeupThread(cmd->thread_id);
@@ -313,17 +319,17 @@ void ReturnMessage(IsoMessage *cmd) {
 /*!
  * Free buffers, close files, and remove from priority stack
  */
-void ReleaseMessage(IsoMessage *cmd) {
+void ReleaseMessage(IsoMessage* cmd) {
   // kill all buffers
-  while(cmd->callback_buffer) {
+  while (cmd->callback_buffer) {
     auto old_head = cmd->callback_buffer;
     cmd->callback_buffer = (IsoBufferHeader*)old_head->next;
-      printf("free 2\n");
+    printf("free 2\n");
     FreeBuffer(old_head);
   }
 
   // close file
-  if(cmd->fd) {
+  if (cmd->fd) {
     isofs->close(cmd->fd);
   }
 
@@ -333,23 +339,22 @@ void ReleaseMessage(IsoMessage *cmd) {
 
 // GetVAGCommand
 VagCommand* GetVAGCommand() {
-  for(;;) {
+  for (;;) {
     // wait for command to be available
-    while(vag_cmd_cnt == (N_VAG_CMDS - 1)) {
+    while (vag_cmd_cnt == (N_VAG_CMDS - 1)) {
       DelayThread(100);
     }
 
     // wait for VAG semaphore
-    while(WaitSema(sSema)) {
-
+    while (WaitSema(sSema)) {
     }
     // try to get something.
-    for(s32 i = 0; i < N_VAG_CMDS; i++) {
-      if(!((vag_cmd_used >> (i & 0x1f)) & 1)) {
+    for (s32 i = 0; i < N_VAG_CMDS; i++) {
+      if (!((vag_cmd_used >> (i & 0x1f)) & 1)) {
         // free!
         vag_cmd_used |= (1 << (i & 0x1f));
         vag_cmd_cnt++;
-        if(vag_cmd_cnt > max_vag_cmd_cnt) {
+        if (vag_cmd_cnt > max_vag_cmd_cnt) {
           max_vag_cmd_cnt = vag_cmd_cnt;
         }
         SignalSema(sSema);
@@ -363,9 +368,8 @@ VagCommand* GetVAGCommand() {
 
 void FreeVAGCommand(VagCommand* cmd) {
   s32 idx = cmd - vag_cmds;
-  if(idx >= 0 && idx < N_VAG_CMDS && ((vag_cmd_used >> (idx & 0x1f)) & 1)) {
-    while(WaitSema(sSema)) {
-
+  if (idx >= 0 && idx < N_VAG_CMDS && ((vag_cmd_used >> (idx & 0x1f)) & 1)) {
+    while (WaitSema(sSema)) {
     }
 
     vag_cmd_used &= ~(1 << (idx & 0x1f));
diff --git a/game/overlord/iso_queue.h b/game/overlord/iso_queue.h
index 79c245ad0c..283b6c4ef7 100644
--- a/game/overlord/iso_queue.h
+++ b/game/overlord/iso_queue.h
@@ -1,21 +1,17 @@
 #ifndef JAK_V2_ISO_QUEUE_H
 #define JAK_V2_ISO_QUEUE_H
 
-
 #include "common/common_types.h"
 #include "isocommon.h"
 
-
-
 void iso_queue_init_globals();
 void InitBuffers();
 IsoBufferHeader* AllocateBuffer(uint32_t size);
-void FreeBuffer(IsoBufferHeader *buffer);
-u32 QueueMessage(IsoMessage *cmd, int32_t priority, const char *name);
-void UnqueueMessage(IsoMessage *cmd);
+void FreeBuffer(IsoBufferHeader* buffer);
+u32 QueueMessage(IsoMessage* cmd, int32_t priority, const char* name);
+void UnqueueMessage(IsoMessage* cmd);
 IsoMessage* GetMessage();
 void ProcessMessageData();
-void ReturnMessage(IsoMessage *cmd);
+void ReturnMessage(IsoMessage* cmd);
 
-
-#endif //JAK_V2_ISO_QUEUE_H
+#endif  // JAK_V2_ISO_QUEUE_H
diff --git a/game/overlord/overlord.cpp b/game/overlord/overlord.cpp
index eea691e7ce..cf0aad18e3 100644
--- a/game/overlord/overlord.cpp
+++ b/game/overlord/overlord.cpp
@@ -12,7 +12,7 @@ int start_overlord(int argc, const char* const* argv) {
   (void)argc;
   FlushDcache();
   CpuEnableIntr();
-  if(!sceSifCheckInit()) {
+  if (!sceSifCheckInit()) {
     sceSifInit();
   }
 
@@ -20,7 +20,7 @@ int start_overlord(int argc, const char* const* argv) {
   InitBanks();
   InitSound_Overlord();
   InitRamdisk();
-//  RegisterVblankHandler(0, 0x20, VBlank_Handler, nullptr);
+  //  RegisterVblankHandler(0, 0x20, VBlank_Handler, nullptr);
 
   ThreadParam thread_param;
   thread_param.attr = TH_C;
@@ -28,37 +28,37 @@ int start_overlord(int argc, const char* const* argv) {
   thread_param.stackSize = 0x800;
   thread_param.option = 0;
   thread_param.entry = (void*)Thread_Server;
-  strcpy(thread_param.name, "Server"); // added
+  strcpy(thread_param.name, "Server");  // added
   auto thread_server = CreateThread(&thread_param);
-  if(thread_server <= 0) {
+  if (thread_server <= 0) {
     return 1;
   }
 
-//  thread_param.attr = TH_C;
-//  thread_param.initPriority = 96;
-//  thread_param.stackSize = 0x800;
-//  thread_param.option = 0;
-//  thread_param.entry = Thread_Player;
-//  auto thread_player = CreateThread(&thread_param);
-//  if(thread_player <= 0) {
-//    return 1;
-//  }
-//
-//  thread_param.attr = TH_C;
-//  thread_param.initPriority = 99;
-//  thread_param.stackSize = 0x1000;
-//  thread_param.option = 0;
-//  thread_param.entry = Thread_Loader;
-//  auto thread_loader = CreateThread(&thread_param);
-//  if(thread_loader <= 0) {
-//    return 1;
-//  }
+  //  thread_param.attr = TH_C;
+  //  thread_param.initPriority = 96;
+  //  thread_param.stackSize = 0x800;
+  //  thread_param.option = 0;
+  //  thread_param.entry = Thread_Player;
+  //  auto thread_player = CreateThread(&thread_param);
+  //  if(thread_player <= 0) {
+  //    return 1;
+  //  }
+  //
+  //  thread_param.attr = TH_C;
+  //  thread_param.initPriority = 99;
+  //  thread_param.stackSize = 0x1000;
+  //  thread_param.option = 0;
+  //  thread_param.entry = Thread_Loader;
+  //  auto thread_loader = CreateThread(&thread_param);
+  //  if(thread_loader <= 0) {
+  //    return 1;
+  //  }
 
   InitISOFS(argv[1], argv[2]);
   StartThread(thread_server, 0);
 
-//  StartThread(thread_player, 0);
-//  StartThread(thread_loader, 0);
+  //  StartThread(thread_player, 0);
+  //  StartThread(thread_loader, 0);
   return 0;
 }
 
@@ -66,7 +66,6 @@ int start_overlord(int argc, const char* const* argv) {
  * Loop endlessly and never return.
  */
 void ExitIOP() {
-  while(true) {
-
+  while (true) {
   }
 }
\ No newline at end of file
diff --git a/game/overlord/overlord.h b/game/overlord/overlord.h
index 4f368c6bc6..18e3f14468 100644
--- a/game/overlord/overlord.h
+++ b/game/overlord/overlord.h
@@ -4,4 +4,4 @@
 int start_overlord(int argc, const char* const* argv);
 void ExitIOP();
 
-#endif //JAK_V2_OVERLORD_H
+#endif  // JAK_V2_OVERLORD_H
diff --git a/game/overlord/sbank.cpp b/game/overlord/sbank.cpp
index ffcb393421..5b88c51c16 100644
--- a/game/overlord/sbank.cpp
+++ b/game/overlord/sbank.cpp
@@ -1,5 +1,3 @@
 #include "sbank.h"
 
-void InitBanks() {
-
-}
+void InitBanks() {}
diff --git a/game/overlord/sbank.h b/game/overlord/sbank.h
index fae812d529..6ea2b8cbe5 100644
--- a/game/overlord/sbank.h
+++ b/game/overlord/sbank.h
@@ -3,4 +3,4 @@
 
 void InitBanks();
 
-#endif //JAK_V2_SBANK_H
+#endif  // JAK_V2_SBANK_H
diff --git a/game/overlord/soundcommon.cpp b/game/overlord/soundcommon.cpp
index 18078840a3..8c153b309c 100644
--- a/game/overlord/soundcommon.cpp
+++ b/game/overlord/soundcommon.cpp
@@ -1,7 +1,6 @@
 #include <assert.h>
 #include "soundcommon.h"
 
-
 void PrintBankInfo(void* buffer) {
   (void)buffer;
   assert(false);
diff --git a/game/overlord/soundcommon.h b/game/overlord/soundcommon.h
index 52886be7ee..34bf6a8b76 100644
--- a/game/overlord/soundcommon.h
+++ b/game/overlord/soundcommon.h
@@ -3,4 +3,4 @@
 
 void PrintBankInfo(void* buffer);
 
-#endif //JAK_V2_SOUNDCOMMON_H
+#endif  // JAK_V2_SOUNDCOMMON_H
diff --git a/game/overlord/srpc.h b/game/overlord/srpc.h
index fd7e9f680b..6cf282f62f 100644
--- a/game/overlord/srpc.h
+++ b/game/overlord/srpc.h
@@ -8,4 +8,4 @@ void srpc_init_globals();
 constexpr int MUSIC_TWEAK_SIZE = 0x204;
 extern u8 gMusicTweakInfo[MUSIC_TWEAK_SIZE];
 
-#endif //JAK_V2_SRPC_H
+#endif  // JAK_V2_SRPC_H
diff --git a/game/overlord/ssound.cpp b/game/overlord/ssound.cpp
index d308c45702..a3fe869cdf 100644
--- a/game/overlord/ssound.cpp
+++ b/game/overlord/ssound.cpp
@@ -1,5 +1,3 @@
 #include "ssound.h"
 
-void InitSound_Overlord() {
-
-}
\ No newline at end of file
+void InitSound_Overlord() {}
\ No newline at end of file
diff --git a/game/overlord/ssound.h b/game/overlord/ssound.h
index 1d19b0d6b6..e7451c135a 100644
--- a/game/overlord/ssound.h
+++ b/game/overlord/ssound.h
@@ -3,4 +3,4 @@
 
 void InitSound_Overlord();
 
-#endif //JAK_V2_SSOUND_H
+#endif  // JAK_V2_SSOUND_H
diff --git a/game/overlord/stream.h b/game/overlord/stream.h
index fd71e298d9..6382244ea9 100644
--- a/game/overlord/stream.h
+++ b/game/overlord/stream.h
@@ -5,4 +5,4 @@
 u32 STRThread();
 u32 PLAYThread();
 
-#endif //JAK_V2_STREAM_H
+#endif  // JAK_V2_STREAM_H
diff --git a/game/sce/deci2.h b/game/sce/deci2.h
index 1af3f8cb27..bc29fc057a 100644
--- a/game/sce/deci2.h
+++ b/game/sce/deci2.h
@@ -10,7 +10,6 @@
 
 class Deci2Server;
 
-
 namespace ee {
 
 void LIBRARY_INIT_sceDeci2();
diff --git a/game/sce/iop.cpp b/game/sce/iop.cpp
index 6f954a0183..dc984c3f00 100644
--- a/game/sce/iop.cpp
+++ b/game/sce/iop.cpp
@@ -31,22 +31,19 @@ void sceSifInitRpc(int mode) {
  * Flush Data Cache
  */
 void FlushDcache() {
-  // Do nothing! The data cache does not need to be flushed on x86 as we have no DMA which bypasses cache.
+  // Do nothing! The data cache does not need to be flushed on x86 as we have no DMA which bypasses
+  // cache.
 }
 
 /*!
  * Enable CPU Interrupts
  */
-void CpuDisableIntr() {
-
-}
+void CpuDisableIntr() {}
 
 /*!
  * Disable CPU Interrupts
  */
-void CpuEnableIntr() {
-
-}
+void CpuEnableIntr() {}
 
 namespace {
 ::IOP* iop;
@@ -68,15 +65,15 @@ void LIBRARY_kill() {
  * How much free memory is there, in bytes?
  */
 int QueryTotalFreeMemSize() {
-  // this value is somewhat arbitrary - it's a lot, but not enough to make OVERLORD think it is running on
-  // an 8MB-of-IOP-RAM development machine.
+  // this value is somewhat arbitrary - it's a lot, but not enough to make OVERLORD think it is
+  // running on an 8MB-of-IOP-RAM development machine.
   return 0x100000;
 }
 
 /*!
-  * Allocate memory.
-  */
-void *AllocSysMemory(int type, unsigned long size, void *addr) {
+ * Allocate memory.
+ */
+void* AllocSysMemory(int type, unsigned long size, void* addr) {
   assert(type == SMEM_Low);
   assert(addr == nullptr);
   return iop->iop_alloc(size);
@@ -112,8 +109,13 @@ void sceSifSetRpcQueue(sceSifQueueData* dq, int key) {
   iop->kernel.set_rpc_queue(dq, key);
 }
 
-void sceSifRegisterRpc(sceSifServeData* serve, unsigned int request,
-                       sceSifRpcFunc func, void* buff, sceSifRpcFunc cfunc, void* cbuff, sceSifQueueData* qd) {
+void sceSifRegisterRpc(sceSifServeData* serve,
+                       unsigned int request,
+                       sceSifRpcFunc func,
+                       void* buff,
+                       sceSifRpcFunc cfunc,
+                       void* cbuff,
+                       sceSifQueueData* qd) {
   serve->command = request;
   serve->func = func;
   serve->buff = buff;
@@ -140,11 +142,11 @@ int sceCdSync(int mode) {
 }
 
 int sceCdGetError() {
-  return 0; // no error
+  return 0;  // no error
 }
 
 int sceCdGetDiskType() {
-  return SCECdPS2DVD; // always a DVD (for now)
+  return SCECdPS2DVD;  // always a DVD (for now)
 }
 
 int sceCdMmode(int media) {
@@ -213,4 +215,4 @@ s32 WakeupThread(s32 thid) {
   iop->kernel.WakeupThread(thid);
   return 0;
 }
-}
\ No newline at end of file
+}  // namespace iop
\ No newline at end of file
diff --git a/game/sce/iop.h b/game/sce/iop.h
index e10908e096..5b65a0d5e0 100644
--- a/game/sce/iop.h
+++ b/game/sce/iop.h
@@ -3,35 +3,34 @@
 
 #include "common/common_types.h"
 
-#define SMEM_Low  (0)
+#define SMEM_Low (0)
 #define SMEM_High (1)
 #define SMEM_Addr (2)
 
-#define SCECdCD         1
-#define SCECdDVD        2
-
-#define SCECdIllgalMedia 	0xff
-#define SCECdIllegalMedia 	0xff
-#define SCECdDVDV		0xfe
-#define SCECdCDDA		0xfd
-#define SCECdPS2DVD		0x14
-#define SCECdPS2CD		0x12
-#define SCECdDETCT		0x01
+#define SCECdCD 1
+#define SCECdDVD 2
 
+#define SCECdIllgalMedia 0xff
+#define SCECdIllegalMedia 0xff
+#define SCECdDVDV 0xfe
+#define SCECdCDDA 0xfd
+#define SCECdPS2DVD 0x14
+#define SCECdPS2CD 0x12
+#define SCECdDETCT 0x01
 
 #define SCECdComplete 0x02
 #define SCECdNotReady 0x06
 #define KE_MBOX_NOMSG -424
 
-#define TH_C    0x02000000
+#define TH_C 0x02000000
 
 class IOP;
 
 namespace iop {
-typedef void * (* sceSifRpcFunc)(unsigned int,void *,int);
+typedef void* (*sceSifRpcFunc)(unsigned int, void*, int);
 
 struct sceSifServeData {
-  unsigned int command; // the RPC ID
+  unsigned int command;  // the RPC ID
   sceSifRpcFunc func;
   void* buff;
 };
@@ -48,14 +47,13 @@ struct sceCdRMode {
   uint8_t pad;
 };
 
-struct sceSifDmaData{
-  void*  data;
-  void*  addr;
-  unsigned int  size;
-  unsigned int  mode;
+struct sceSifDmaData {
+  void* data;
+  void* addr;
+  unsigned int size;
+  unsigned int mode;
 };
 
-
 struct SysClock {
   uint32_t hi, lo;
 };
@@ -72,7 +70,7 @@ struct MbxParam {
 struct ThreadParam {
   u32 attr;
   u32 option;
-  void *entry;
+  void* entry;
   int stackSize;
   int initPriority;
 
@@ -87,9 +85,9 @@ struct SemaParam {
   uint32_t option;
 };
 
-//void PS2_RegisterIOP(IOP *iop);
+// void PS2_RegisterIOP(IOP *iop);
 int QueryTotalFreeMemSize();
-void *AllocSysMemory(int type, unsigned long size, void *addr);
+void* AllocSysMemory(int type, unsigned long size, void* addr);
 
 int GetThreadId();
 void CpuDisableIntr();
@@ -103,8 +101,13 @@ s32 WakeupThread(s32 thid);
 void sceSifInitRpc(int mode);
 void sceSifInitRpc(unsigned int mode);
 void sceSifSetRpcQueue(sceSifQueueData* dq, int key);
-void sceSifRegisterRpc(sceSifServeData* serve, unsigned int request,
-                       sceSifRpcFunc func, void* buff, sceSifRpcFunc cfunc, void* cbuff, sceSifQueueData* qd);
+void sceSifRegisterRpc(sceSifServeData* serve,
+                       unsigned int request,
+                       sceSifRpcFunc func,
+                       void* buff,
+                       sceSifRpcFunc cfunc,
+                       void* cbuff,
+                       sceSifQueueData* qd);
 void sceSifRpcLoop(sceSifQueueData* pd);
 
 int sceCdRead(uint32_t logical_sector, uint32_t sectors, void* buf, sceCdRMode* mode);
@@ -135,6 +138,6 @@ void sceSifInit();
 void LIBRARY_INIT();
 void LIBRARY_register(::IOP* i);
 void LIBRARY_kill();
-}
+}  // namespace iop
 
 #endif  // JAK1_IOP_H
diff --git a/game/sce/libcdvd_ee.cpp b/game/sce/libcdvd_ee.cpp
index 32e2cc95d7..18fcd01f99 100644
--- a/game/sce/libcdvd_ee.cpp
+++ b/game/sce/libcdvd_ee.cpp
@@ -11,7 +11,7 @@ namespace ee {
 namespace {
 // CD/DVD media type set by sceCdMMode
 int media_mode;
-}
+}  // namespace
 
 void LIBRARY_INIT_sceCd() {
   media_mode = -1;
@@ -21,9 +21,9 @@ void LIBRARY_INIT_sceCd() {
  * Initialize the CD/DVD subsystem.
  * init_mode should be SCECdINIT
  */
-int sceCdInit(int init_mode){
+int sceCdInit(int init_mode) {
   assert(init_mode == SCECdINIT);
-  return 1; // Initialization was performed normally
+  return 1;  // Initialization was performed normally
 }
 
 /*!
@@ -31,7 +31,7 @@ int sceCdInit(int init_mode){
  */
 int sceCdMmode(int media) {
   media_mode = media;
-  return 1; // If successful, returns 1
+  return 1;  // If successful, returns 1
 }
 
 /*!
@@ -49,7 +49,7 @@ int sceCdDiskReady(int mode) {
  */
 int sceCdGetDiskType() {
   // if we set CD or DVD, return the appropriate PS2 game disk type.
-  switch(media_mode) {
+  switch (media_mode) {
     case SCECdCD:
       return SCECdPS2CD;
     case SCECdDVD:
diff --git a/game/sce/libscf.cpp b/game/sce/libscf.cpp
index c059cfe5dd..5a18fc00fa 100644
--- a/game/sce/libscf.cpp
+++ b/game/sce/libscf.cpp
@@ -8,4 +8,4 @@ int sceScfGetAspect() {
 int sceScfGetLanguage() {
   return SCE_ENGLISH_LANGUAGE;
 }
-}
\ No newline at end of file
+}  // namespace ee
\ No newline at end of file
diff --git a/game/sce/libscf.h b/game/sce/libscf.h
index 6647c0cc7c..662c005cde 100644
--- a/game/sce/libscf.h
+++ b/game/sce/libscf.h
@@ -26,6 +26,6 @@ int sceScfGetAspect();
  * Return a SONY SCE_LANGUAGE value, which differs from GOAL.
  */
 int sceScfGetLanguage();
-}
+}  // namespace ee
 
 #endif  // JAK1_LIBSCF_H
diff --git a/game/sce/sif_ee.cpp b/game/sce/sif_ee.cpp
index e13e32d2d2..b37ab58d54 100644
--- a/game/sce/sif_ee.cpp
+++ b/game/sce/sif_ee.cpp
@@ -6,7 +6,7 @@
 
 namespace ee {
 
-namespace  {
+namespace {
 ::IOP* iop;
 }
 
@@ -30,17 +30,16 @@ int sceSifSyncIop() {
   return 1;
 }
 
-void sceFsReset() {
-
-}
+void sceFsReset() {}
 
 int sceSifLoadModule(const char* name, int arg_size, const char* args) {
-  if(!strcmp(name, "cdrom0:\\\\DRIVERS\\\\OVERLORD.IRX;1") || !strcmp(name, "host0:binee/overlord.irx")) {
+  if (!strcmp(name, "cdrom0:\\\\DRIVERS\\\\OVERLORD.IRX;1") ||
+      !strcmp(name, "host0:binee/overlord.irx")) {
     const char* src = args;
     char* dst = iop->overlord_arg_data;
     int cnt;
     iop->overlord_argv[0] = nullptr;
-    for(cnt = 1; src - args < arg_size; cnt++) {
+    for (cnt = 1; src - args < arg_size; cnt++) {
       auto len = strlen(src);
       memcpy(dst, src, len + 1);
       iop->overlord_argv[cnt] = dst;
@@ -49,8 +48,8 @@ int sceSifLoadModule(const char* name, int arg_size, const char* args) {
     }
     iop->overlord_argc = cnt;
 
-    for(int i = 0; i < cnt; i++) {
-      if(iop->overlord_argv[i])
+    for (int i = 0; i < cnt; i++) {
+      if (iop->overlord_argv[i])
         printf("arg %d : %s\n", i, iop->overlord_argv[i]);
     }
     iop->set_ee_main_mem(g_ee_main_mem);
@@ -65,10 +64,18 @@ int sceMcInit() {
   return 1;
 }
 
-s32 sceSifCallRpc(sceSifClientData* bd, u32 fno, u32 mode, void* send, s32 ssize, void* recv, s32 rsize, void* end_func, void* end_para) {
+s32 sceSifCallRpc(sceSifClientData* bd,
+                  u32 fno,
+                  u32 mode,
+                  void* send,
+                  s32 ssize,
+                  void* recv,
+                  s32 rsize,
+                  void* end_func,
+                  void* end_para) {
   assert(!end_func);
   assert(!end_para);
-  assert(mode == 1); // async
+  assert(mode == 1);  // async
   iop->kernel.sif_rpc(bd->rpcd.id, fno, mode, send, ssize, recv, rsize);
   return 0;
 }
@@ -79,9 +86,9 @@ s32 sceSifCheckStatRpc(sceSifRpcData* bd) {
 }
 
 s32 sceSifBindRpc(sceSifClientData* bd, u32 request, u32 mode) {
-  assert(mode == 1); // async
+  assert(mode == 1);  // async
   bd->rpcd.id = request;
   bd->serve = (sceSifServeData*)1;
   return 0;
 }
-}
\ No newline at end of file
+}  // namespace ee
\ No newline at end of file
diff --git a/game/sce/sif_ee.h b/game/sce/sif_ee.h
index 174e5d5590..3d3186e1b7 100644
--- a/game/sce/sif_ee.h
+++ b/game/sce/sif_ee.h
@@ -16,17 +16,16 @@ struct sceSifServeData {
 };
 
 struct sceSifClientData {
-  sceSifRpcData  rpcd;
-//  unsigned int  command;
-  void    *buff;
-  void    *gp;
-//  sceSifEndFunc func;
-  void    *para;
-//  struct _sif_serve_data    *serve;
-  sceSifServeData *serve;
+  sceSifRpcData rpcd;
+  //  unsigned int  command;
+  void* buff;
+  void* gp;
+  //  sceSifEndFunc func;
+  void* para;
+  //  struct _sif_serve_data    *serve;
+  sceSifServeData* serve;
 };
 
-
 void LIBRARY_sceSif_register(::IOP* i);
 void LIBRARY_INIT_sceSif();
 
@@ -36,9 +35,17 @@ int sceSifSyncIop();
 void sceFsReset();
 int sceSifLoadModule(const char* name, int arg_size, const char* args);
 int sceMcInit();
-s32 sceSifCallRpc(sceSifClientData* bd, u32 fno, u32 mode, void* send, s32 ssize, void* recv, s32 rsize, void* end_func, void* end_para);
+s32 sceSifCallRpc(sceSifClientData* bd,
+                  u32 fno,
+                  u32 mode,
+                  void* send,
+                  s32 ssize,
+                  void* recv,
+                  s32 rsize,
+                  void* end_func,
+                  void* end_para);
 s32 sceSifCheckStatRpc(sceSifRpcData* bd);
 s32 sceSifBindRpc(sceSifClientData* bd, u32 request, u32 mode);
 
-}
+}  // namespace ee
 #endif  // JAK1_SIF_EE_H
diff --git a/game/sce/stubs.cpp b/game/sce/stubs.cpp
index 4e218a4739..67cb9bd1b2 100644
--- a/game/sce/stubs.cpp
+++ b/game/sce/stubs.cpp
@@ -3,7 +3,7 @@
 #include "stubs.h"
 
 namespace ee {
-s32 sceOpen(const char *filename, s32 flag) {
+s32 sceOpen(const char* filename, s32 flag) {
   (void)filename;
   (void)flag;
   throw std::runtime_error("sceOpen NYI");
@@ -14,14 +14,14 @@ s32 sceClose(s32 fd) {
   throw std::runtime_error("sceClose NYI");
 }
 
-s32 sceRead(s32 fd, void *buf, s32 nbyte) {
+s32 sceRead(s32 fd, void* buf, s32 nbyte) {
   (void)fd;
   (void)buf;
   (void)nbyte;
   throw std::runtime_error("sceRead NYI");
 }
 
-s32 sceWrite(s32 fd, const void *buf, s32 nbyte) {
+s32 sceWrite(s32 fd, const void* buf, s32 nbyte) {
   (void)fd;
   (void)buf;
   (void)nbyte;
@@ -79,7 +79,7 @@ void FlushCache() {
   assert(false);
 }
 
-}
+}  // namespace ee
 
 namespace iop {
 u32 snd_BankLoadByLoc(u32 sector, u32 unk) {
@@ -98,4 +98,4 @@ void snd_ResolveBankXREFS() {
   assert(false);
 }
 
-}
+}  // namespace iop
diff --git a/game/sce/stubs.h b/game/sce/stubs.h
index 3ce2b5a781..af4110d243 100644
--- a/game/sce/stubs.h
+++ b/game/sce/stubs.h
@@ -4,33 +4,33 @@
 #include "common/common_types.h"
 
 #ifndef SCE_SEEK_SET
-#define SCE_SEEK_SET        (0)
+#define SCE_SEEK_SET (0)
 #endif
 #ifndef SCE_SEEK_CUR
-#define SCE_SEEK_CUR        (1)
+#define SCE_SEEK_CUR (1)
 #endif
 #ifndef SCE_SEEK_END
-#define SCE_SEEK_END        (2)
+#define SCE_SEEK_END (2)
 #endif
 
-#define SCE_RDONLY      0x0001
-#define SCE_WRONLY      0x0002
-#define SCE_RDWR        0x0003
-#define SCE_NBLOCK      0x0010
-#define SCE_APPEND      0x0100
-#define SCE_CREAT       0x0200
-#define SCE_TRUNC       0x0400
-#define SCE_EXCL        0x0800
-#define SCE_NOBUF       0x4000
-#define SCE_NOWAIT      0x8000
+#define SCE_RDONLY 0x0001
+#define SCE_WRONLY 0x0002
+#define SCE_RDWR 0x0003
+#define SCE_NBLOCK 0x0010
+#define SCE_APPEND 0x0100
+#define SCE_CREAT 0x0200
+#define SCE_TRUNC 0x0400
+#define SCE_EXCL 0x0800
+#define SCE_NOBUF 0x4000
+#define SCE_NOWAIT 0x8000
 
 #define SCE_PAD_DMA_BUFFER_SIZE 0x100
 
 namespace ee {
-s32 sceOpen(const char *filename, s32 flag);
+s32 sceOpen(const char* filename, s32 flag);
 s32 sceClose(s32 fd);
-s32 sceRead(s32 fd, void *buf, s32 nbyte);
-s32 sceWrite(s32 fd, const void *buf, s32 nbyte);
+s32 sceRead(s32 fd, void* buf, s32 nbyte);
+s32 sceWrite(s32 fd, const void* buf, s32 nbyte);
 s32 sceLseek(s32 fd, s32 offset, s32 where);
 void sceGsSyncV();
 void sceGsSyncPath();
@@ -42,13 +42,12 @@ void sceGsGetIMR();
 void sceGsExecStoreImage();
 void FlushCache();
 int scePadPortOpen(int port, int slot, void* data);
-}
+}  // namespace ee
 
 namespace iop {
 u32 snd_BankLoadByLoc(u32 sector, u32 unk);
 u32 snd_GetLastLoadError();
 void snd_ResolveBankXREFS();
-}
-
+}  // namespace iop
 
 #endif  // JAK1_STUBS_H
diff --git a/game/system/Deci2Server.h b/game/system/Deci2Server.h
index 5b5808e678..e57b267466 100644
--- a/game/system/Deci2Server.h
+++ b/game/system/Deci2Server.h
@@ -30,14 +30,13 @@ class Deci2Server {
 
   void run();
 
-
  private:
   void accept_thread_func();
   bool kill_accept_thread = false;
   char* buffer = nullptr;
-  int server_fd;
+  int server_fd = -1;
   sockaddr_in addr;
-  int new_sock;
+  int new_sock = -1;
   bool server_initialized = false;
   bool accept_thread_running = false;
   bool server_connected = false;
@@ -51,8 +50,6 @@ class Deci2Server {
   int* d2_driver_count = nullptr;
 };
 
-
-
 #endif  // JAK1_DECI2SERVER_H
 
 */
\ No newline at end of file
diff --git a/game/system/IOP_Kernel.cpp b/game/system/IOP_Kernel.cpp
index ffa2a9cbad..21ecdb47fe 100644
--- a/game/system/IOP_Kernel.cpp
+++ b/game/system/IOP_Kernel.cpp
@@ -7,16 +7,18 @@
  * Create a new thread.  Will not run the thread.
  */
 s32 IOP_Kernel::CreateThread(std::string name, u32 (*func)()) {
-  if(_currentThread != -1) throw std::runtime_error("tried to create thread from thread");
+  if (_currentThread != -1)
+    throw std::runtime_error("tried to create thread from thread");
   u32 ID = (u32)_nextThID++;
-  if(threads.size() != ID) throw std::runtime_error("thread number error?");
+  if (threads.size() != ID)
+    throw std::runtime_error("thread number error?");
   // add entry
   threads.emplace_back(name, func, ID, this);
   // setup the thread!
   // printf("[IOP Kernel] SetupThread %s...\n", name.c_str());
 
   // hack to allow creating a "null thread" which doesn't/can't run but occupies slot 0.
-  if(func) {
+  if (func) {
     _currentThread = ID;
     // create OS thread, will run the setupThread function
     threads.back().thread = new std::thread(&IOP_Kernel::setupThread, this, ID);
@@ -26,7 +28,6 @@ s32 IOP_Kernel::CreateThread(std::string name, u32 (*func)()) {
     _currentThread = -1;
   }
 
-
   return ID;
 }
 
@@ -34,8 +35,8 @@ s32 IOP_Kernel::CreateThread(std::string name, u32 (*func)()) {
  * Start a thread.  Runs it once, then marks it to run on each dispatch of the IOP kernel.
  */
 void IOP_Kernel::StartThread(s32 id) {
-  threads.at(id).started = true; // mark for run
-  runThread(id); // run now
+  threads.at(id).started = true;  // mark for run
+  runThread(id);                  // run now
 }
 
 /*!
@@ -46,7 +47,7 @@ void IOP_Kernel::setupThread(s32 id) {
   returnToKernel();
   threads.at(id).waitForDispatch();
   // printf("[IOP Kernel] Thread %s first dispatch!\n", threads.at(id).name.c_str());
-  if(_currentThread != id) {
+  if (_currentThread != id) {
     throw std::runtime_error("the wrong thread has run!\n");
   }
   (threads.at(id).function)();
@@ -59,7 +60,8 @@ void IOP_Kernel::setupThread(s32 id) {
  * Run a thread (call from kernel)
  */
 void IOP_Kernel::runThread(s32 id) {
-  if(_currentThread != -1) throw std::runtime_error("tried to runThread in a thread");
+  if (_currentThread != -1)
+    throw std::runtime_error("tried to runThread in a thread");
   _currentThread = id;
   threads.at(id).dispatch();
   threads.at(id).waitForReturnToKernel();
@@ -75,7 +77,7 @@ void IOP_Kernel::SuspendThread() {
   s32 oldThread = getCurrentThread();
   threads.at(oldThread).returnToKernel();
   threads.at(oldThread).waitForDispatch();
-  if(_currentThread != oldThread) {
+  if (_currentThread != oldThread) {
     throw std::runtime_error("bad resume");
   }
 }
@@ -84,9 +86,9 @@ void IOP_Kernel::SuspendThread() {
  * Sleep a thread.  Must be explicitly woken up.
  */
 void IOP_Kernel::SleepThread() {
-  if(getCurrentThread() == -1) {
+  if (getCurrentThread() == -1) {
     mainThreadSleep = true;
-    while(mainThreadSleep) {
+    while (mainThreadSleep) {
       dispatchAll();
     }
   } else {
@@ -99,7 +101,7 @@ void IOP_Kernel::SleepThread() {
  * Wake up a thread. Doesn't run it immediately though.
  */
 void IOP_Kernel::WakeupThread(s32 id) {
-  if(id == -1) {
+  if (id == -1) {
     mainThreadSleep = false;
   } else {
     threads.at(id).started = true;
@@ -111,14 +113,14 @@ void IOP_Kernel::WakeupThread(s32 id) {
  * Dispatch all IOP threads.
  */
 void IOP_Kernel::dispatchAll() {
-  for(u64 i = 0; i < threads.size(); i++) {
-    if(threads[i].started && !threads[i].done) {
-//      printf("[IOP Kernel] Dispatch %s (%ld)\n", threads[i].name.c_str(), i);
+  for (u64 i = 0; i < threads.size(); i++) {
+    if (threads[i].started && !threads[i].done) {
+      //      printf("[IOP Kernel] Dispatch %s (%ld)\n", threads[i].name.c_str(), i);
       _currentThread = i;
       threads[i].dispatch();
       threads[i].waitForReturnToKernel();
       _currentThread = -1;
-      //printf("[IOP Kernel] back to kernel!\n");
+      // printf("[IOP Kernel] back to kernel!\n");
     }
   }
 }
@@ -128,7 +130,8 @@ void IOP_Kernel::dispatchAll() {
  */
 void IopThreadRecord::returnToKernel() {
   runThreadReady = false;
-  if(kernel->getCurrentThread() != thID) throw std::runtime_error("tried to sleep the wrong thread!");
+  if (kernel->getCurrentThread() != thID)
+    throw std::runtime_error("tried to sleep the wrong thread!");
 
   {
     std::lock_guard<std::mutex> lck(*threadToKernelMutex);
@@ -142,7 +145,8 @@ void IopThreadRecord::returnToKernel() {
  */
 void IopThreadRecord::dispatch() {
   syscallReady = false;
-  if(kernel->getCurrentThread() != thID) throw std::runtime_error("tried to dispatch the wrong thread!");
+  if (kernel->getCurrentThread() != thID)
+    throw std::runtime_error("tried to dispatch the wrong thread!");
   {
     std::lock_guard<std::mutex> lck(*kernelToThreadMutex);
     runThreadReady = true;
@@ -155,22 +159,22 @@ void IopThreadRecord::dispatch() {
  */
 void IopThreadRecord::waitForReturnToKernel() {
   std::unique_lock<std::mutex> lck(*threadToKernelMutex);
-  threadToKernelCV->wait(lck, [this]{return syscallReady;});
-//  syscallReady = false;
+  threadToKernelCV->wait(lck, [this] { return syscallReady; });
+  //  syscallReady = false;
 }
 
 /*!
  * Thread waits for kernel to dispatch it.
  */
 void IopThreadRecord::waitForDispatch() {
-  //if(kernel->getCurrentThread() == -1) throw std::runtime_error("tried to suspend main!\n");
+  // if(kernel->getCurrentThread() == -1) throw std::runtime_error("tried to suspend main!\n");
   std::unique_lock<std::mutex> lck(*kernelToThreadMutex);
-  kernelToThreadCV->wait(lck, [this]{return runThreadReady;});
-  //runThreadReady = false;
+  kernelToThreadCV->wait(lck, [this] { return runThreadReady; });
+  // runThreadReady = false;
 }
 
-void IOP_Kernel::set_rpc_queue(iop::sceSifQueueData *qd, u32 thread) {
-  for(const auto& r : sif_records) {
+void IOP_Kernel::set_rpc_queue(iop::sceSifQueueData* qd, u32 thread) {
+  for (const auto& r : sif_records) {
     assert(!(r.qd == qd || r.thread_to_wake == thread));
   }
   SifRecord rec;
@@ -179,14 +183,14 @@ void IOP_Kernel::set_rpc_queue(iop::sceSifQueueData *qd, u32 thread) {
   sif_records.push_back(rec);
 }
 
-typedef void * (* sif_rpc_handler)(unsigned int,void *,int);
+typedef void* (*sif_rpc_handler)(unsigned int, void*, int);
 
 bool IOP_Kernel::sif_busy(u32 id) {
   sif_mtx.lock();
   bool rv = false;
   bool found = false;
-  for(auto& r : sif_records) {
-    if(r.qd->serve_data->command == id) {
+  for (auto& r : sif_records) {
+    if (r.qd->serve_data->command == id) {
       rv = !r.cmd.finished;
       found = true;
       break;
@@ -197,14 +201,19 @@ bool IOP_Kernel::sif_busy(u32 id) {
   return rv;
 }
 
-void IOP_Kernel::sif_rpc(s32 rpcChannel, u32 fno, bool async, void *sendBuff, s32 sendSize, void *recvBuff,
+void IOP_Kernel::sif_rpc(s32 rpcChannel,
+                         u32 fno,
+                         bool async,
+                         void* sendBuff,
+                         s32 sendSize,
+                         void* recvBuff,
                          s32 recvSize) {
   assert(async);
   sif_mtx.lock();
   // step 1 - find entry
   SifRecord* rec = nullptr;
-  for(auto& e : sif_records) {
-    if(e.qd->serve_data->command == (u32)rpcChannel) {
+  for (auto& e : sif_records) {
+    if (e.qd->serve_data->command == (u32)rpcChannel) {
       rec = &e;
     }
   }
@@ -229,15 +238,15 @@ void IOP_Kernel::sif_rpc(s32 rpcChannel, u32 fno, bool async, void *sendBuff, s3
 }
 
 void IOP_Kernel::rpc_loop(iop::sceSifQueueData* qd) {
-  while(true) {
+  while (true) {
     bool got_cmd = false;
     SifRpcCommand cmd;
     sif_rpc_handler func = nullptr;
 
     // get command and mark it as started if we get it
     sif_mtx.lock();
-    for(auto& r : sif_records) {
-      if(r.qd == qd) {
+    for (auto& r : sif_records) {
+      if (r.qd == qd) {
         cmd = r.cmd;
         got_cmd = true;
         r.cmd.started = true;
@@ -247,41 +256,40 @@ void IOP_Kernel::rpc_loop(iop::sceSifQueueData* qd) {
     sif_mtx.unlock();
 
     // handle command
-    if(got_cmd) {
-      if(cmd.shutdown_now) {
+    if (got_cmd) {
+      if (cmd.shutdown_now) {
         return;
       }
 
-      if(!cmd.started) {
+      if (!cmd.started) {
         // cf
         assert(func);
         auto data = func(cmd.fno, cmd.buff, cmd.size);
-        if(cmd.copy_back_buff && cmd.copy_back_size) {
+        if (cmd.copy_back_buff && cmd.copy_back_size) {
           memcpy(cmd.copy_back_buff, data, cmd.copy_back_size);
         }
 
         sif_mtx.lock();
-        for(auto& r : sif_records) {
-          if(r.qd == qd) {
+        for (auto& r : sif_records) {
+          if (r.qd == qd) {
             assert(r.cmd.started);
             r.cmd.finished = true;
           }
         }
         sif_mtx.unlock();
-
       }
     }
     SuspendThread();
   }
 }
 
-void IOP_Kernel::read_disc_sectors(u32 sector, u32 sectors, void *buffer) {
-  if(!iso_disc_file) {
+void IOP_Kernel::read_disc_sectors(u32 sector, u32 sectors, void* buffer) {
+  if (!iso_disc_file) {
     iso_disc_file = fopen("./disc.iso", "rb");
   }
 
   assert(iso_disc_file);
-  if(fseek(iso_disc_file, sector * 0x800, SEEK_SET)) {
+  if (fseek(iso_disc_file, sector * 0x800, SEEK_SET)) {
     assert(false);
   }
   auto rv = fread(buffer, sectors * 0x800, 1, iso_disc_file);
@@ -290,17 +298,18 @@ void IOP_Kernel::read_disc_sectors(u32 sector, u32 sectors, void *buffer) {
 
 void IOP_Kernel::shutdown() {
   // shutdown most threads
-  for(auto& r : sif_records) {
+  for (auto& r : sif_records) {
     r.cmd.shutdown_now = true;
   }
 
-  for(auto& t : threads) {
+  for (auto& t : threads) {
     t.wantExit = true;
   }
 
-  for(auto& t : threads) {
-    if(t.thID == 0) continue;
-    while(!t.done) {
+  for (auto& t : threads) {
+    if (t.thID == 0)
+      continue;
+    while (!t.done) {
       dispatchAll();
     }
     t.thread->join();
@@ -308,7 +317,7 @@ void IOP_Kernel::shutdown() {
 }
 
 IOP_Kernel::~IOP_Kernel() {
-  if(iso_disc_file) {
+  if (iso_disc_file) {
     fclose(iso_disc_file);
   }
 }
\ No newline at end of file
diff --git a/game/system/IOP_Kernel.h b/game/system/IOP_Kernel.h
index d05083dbc8..488718ffce 100644
--- a/game/system/IOP_Kernel.h
+++ b/game/system/IOP_Kernel.h
@@ -12,7 +12,7 @@
 
 class IOP_Kernel;
 namespace iop {
-  struct sceSifQueueData;
+struct sceSifQueueData;
 }
 
 struct SifRpcCommand {
@@ -28,7 +28,6 @@ struct SifRpcCommand {
   int copy_back_size;
 };
 
-
 struct SifRecord {
   iop::sceSifQueueData* qd;
   SifRpcCommand cmd;
@@ -36,14 +35,14 @@ struct SifRecord {
 };
 
 struct IopThreadRecord {
-  IopThreadRecord(std::string n, u32 (*f)(), s32 ID, IOP_Kernel* k) : name(n), function(f), thID(ID), kernel(k) {
+  IopThreadRecord(std::string n, u32 (*f)(), s32 ID, IOP_Kernel* k)
+      : name(n), function(f), thID(ID), kernel(k) {
     kernelToThreadCV = new std::condition_variable;
     threadToKernelCV = new std::condition_variable;
     kernelToThreadMutex = new std::mutex;
     threadToKernelMutex = new std::mutex;
   }
 
-
   ~IopThreadRecord() {
     delete kernelToThreadCV;
     delete threadToKernelCV;
@@ -72,9 +71,8 @@ struct IopThreadRecord {
   void dispatch();
 };
 
-
 class IOP_Kernel {
-public:
+ public:
   IOP_Kernel() {
     // this ugly hack
     threads.reserve(16);
@@ -90,7 +88,7 @@ public:
   void SleepThread();
   void WakeupThread(s32 id);
   void dispatchAll();
-  void set_rpc_queue(iop::sceSifQueueData *qd, u32 thread);
+  void set_rpc_queue(iop::sceSifQueueData* qd, u32 thread);
   void rpc_loop(iop::sceSifQueueData* qd);
   void shutdown();
 
@@ -98,17 +96,15 @@ public:
    * Resume the kernel.
    */
   void returnToKernel() {
-    if(_currentThread < 0) throw std::runtime_error("tried to return to kernel not in a thread");
+    if (_currentThread < 0)
+      throw std::runtime_error("tried to return to kernel not in a thread");
     threads[_currentThread].returnToKernel();
   }
 
   /*!
    * Get current thread ID.
    */
-  s32 getCurrentThread() {
-    return _currentThread;
-  }
-
+  s32 getCurrentThread() { return _currentThread; }
 
   /*!
    * Create a message box
@@ -124,17 +120,18 @@ public:
    * Returns if it got something.
    */
   s32 PollMbx(void** msg, s32 mbx) {
-    if(_currentThread != -1 && threads.at(_currentThread).wantExit) {
+    if (_currentThread != -1 && threads.at(_currentThread).wantExit) {
       // total hack - returning this value causes the ISO thread to error out and quit.
       return -0x1a9;
     }
-//    printf("poll %d %ld\n", mbx, mbxs.size());
-    if(mbx >= (s32) mbxs.size()) throw std::runtime_error("invalid PollMbx");
-    s32 gotSomething =  mbxs[mbx].empty() ? 0 : 1;
-    if(gotSomething) {
+    //    printf("poll %d %ld\n", mbx, mbxs.size());
+    if (mbx >= (s32)mbxs.size())
+      throw std::runtime_error("invalid PollMbx");
+    s32 gotSomething = mbxs[mbx].empty() ? 0 : 1;
+    if (gotSomething) {
       void* thing = mbxs[mbx].front();
-//      printf("pop from msgbox %d %p\n", mbx, thing);
-      if(msg)
+      //      printf("pop from msgbox %d %p\n", mbx, thing);
+      if (msg)
         *msg = thing;
       mbxs[mbx].pop();
     }
@@ -146,24 +143,28 @@ public:
    * Push something into a mbx
    */
   s32 SendMbx(s32 mbx, void* value) {
-    if(mbx >= (s32) mbxs.size()) throw std::runtime_error("invalid SendMbx");
+    if (mbx >= (s32)mbxs.size())
+      throw std::runtime_error("invalid SendMbx");
     mbxs[mbx].push(value);
-//    printf("push into messagebox %d %p\n", mbx, value);
-//    printf("mbx size %ld\n", mbxs.size());
+    //    printf("push into messagebox %d %p\n", mbx, value);
+    //    printf("mbx size %ld\n", mbxs.size());
     return 0;
   }
 
-  s32 CreateSema() {
-    return 1;
-  }
+  s32 CreateSema() { return 1; }
 
   void read_disc_sectors(u32 sector, u32 sectors, void* buffer);
   bool sif_busy(u32 id);
 
-  void sif_rpc(s32 rpcChannel, u32 fno, bool async, void *sendBuff, s32 sendSize, void *recvBuff, s32 recvSize);
+  void sif_rpc(s32 rpcChannel,
+               u32 fno,
+               bool async,
+               void* sendBuff,
+               s32 sendSize,
+               void* recvBuff,
+               s32 recvSize);
 
-
-private:
+ private:
   void setupThread(s32 id);
   void runThread(s32 id);
   s32 _nextThID = 0;
@@ -176,5 +177,4 @@ private:
   std::mutex sif_mtx;
 };
 
-
-#endif //JAK_IOP_KERNEL_H
+#endif  // JAK_IOP_KERNEL_H
diff --git a/game/system/SystemThread.h b/game/system/SystemThread.h
index 7744c0afb7..522b0f9925 100644
--- a/game/system/SystemThread.h
+++ b/game/system/SystemThread.h
@@ -13,7 +13,6 @@
 #include <condition_variable>
 #include "Timer.h"
 
-
 constexpr int MAX_SYSTEM_THREADS = 16;
 
 class SystemThreadInterface;
@@ -27,13 +26,13 @@ class SystemThreadManager;
  * statistics.
  */
 class SystemThread {
-public:
+ public:
   void start(std::function<void(SystemThreadInterface&)> f);
   void join();
   void stop();
   SystemThread() = default;
 
-private:
+ private:
   friend class SystemThreadInterface;
   friend class SystemThreadManager;
   friend void* bootstrap_thread_func(void* thd);
@@ -41,7 +40,7 @@ private:
   std::string name = "invalid";
   std::thread thread;
   SystemThreadManager* manager;
-  std::function<void(SystemThreadInterface &)> function;
+  std::function<void(SystemThreadInterface&)> function;
   bool initialization_complete = false;
   std::mutex initialization_mutex;
   std::condition_variable initialization_cv;
@@ -59,15 +58,14 @@ private:
  * The interfaces used by a thread in the runtime.
  */
 class SystemThreadInterface {
-public:
-  SystemThreadInterface(SystemThread* p) : thread(*p) {
-
-  }
+ public:
+  SystemThreadInterface(SystemThread* p) : thread(*p) {}
   void initialization_complete();
   void report_perf_stats();
   bool get_want_exit() const;
   void trigger_shutdown();
-private:
+
+ private:
   SystemThread& thread;
 };
 
@@ -75,14 +73,15 @@ private:
  * A manager of all threads in the runtime.
  */
 class SystemThreadManager {
-public:
+ public:
   SystemThread& create_thread(const std::string& name);
   void print_stats();
   void shutdown();
   void join();
-private:
+
+ private:
   std::array<SystemThread, MAX_SYSTEM_THREADS> threads;
   int thread_count = 0;
 };
 
-#endif //RUNTIME_SYSTEMTHREAD_H
+#endif  // RUNTIME_SYSTEMTHREAD_H
diff --git a/game/system/Timer.h b/game/system/Timer.h
index fd2b1667dd..ccdfbb742a 100644
--- a/game/system/Timer.h
+++ b/game/system/Timer.h
@@ -6,30 +6,23 @@
 #include <cstdint>
 
 class Timer {
-public:
-  explicit Timer() {
-    start();
-  }
+ public:
+  explicit Timer() { start(); }
 
-  void start() {
-  }
+  void start() { clock_gettime(CLOCK_MONOTONIC, &_startTime); }
 
-  double getMs() {
-    return (double)getNs() / 1.e6;
-  }
+  double getMs() { return (double)getNs() / 1.e6; }
 
   int64_t getNs() {
     struct timespec now;
-    return (int64_t)(now.tv_nsec - _startTime.tv_nsec) + 1000000000 * (now.tv_sec - _startTime.tv_sec);
-
+    clock_gettime(CLOCK_MONOTONIC, &now);
+    return (int64_t)(now.tv_nsec - _startTime.tv_nsec) +
+           1000000000 * (now.tv_sec - _startTime.tv_sec);
   }
 
-  double getSeconds() {
-    return (double)getNs() / 1.e9;
-  }
+  double getSeconds() { return (double)getNs() / 1.e9; }
 
   struct timespec _startTime;
 };
 
-
-#endif //RUNTIME_TIMER_H
+#endif  // RUNTIME_TIMER_H
diff --git a/game/system/deci_common.h b/game/system/deci_common.h
index c8a73cceee..94760abca6 100644
--- a/game/system/deci_common.h
+++ b/game/system/deci_common.h
@@ -5,7 +5,7 @@
 struct Deci2Driver {
   u16 protocol = 0;
   void* opt = nullptr;
-  void (*handler)(s32 event, s32 param, void *opt) = nullptr;
+  void (*handler)(s32 event, s32 param, void* opt) = nullptr;
   u8 id = 0;
   bool active = false;
   void* recv_buffer = nullptr;
diff --git a/game/system/iop_thread.cpp b/game/system/iop_thread.cpp
index 1dd81d1e01..bf6cf4e396 100644
--- a/game/system/iop_thread.cpp
+++ b/game/system/iop_thread.cpp
@@ -23,10 +23,7 @@
 //#include "overlord/ssound.h"
 //#include "overlord/stream.h"
 
-
-IOP::IOP() {
-
-}
+IOP::IOP() {}
 
 void IOP::send_status(IOP_Status new_status) {
   {
@@ -38,16 +35,18 @@ void IOP::send_status(IOP_Status new_status) {
 
 void IOP::wait_for_overlord_start_cmd() {
   std::unique_lock<std::mutex> lk(iop_mutex);
-  if(status != IOP_WAIT_FOR_LOAD) return;
+  if (status != IOP_WAIT_FOR_LOAD)
+    return;
 
-  cv.wait(lk, [&]{return status != IOP_WAIT_FOR_LOAD;});
+  cv.wait(lk, [&] { return status != IOP_WAIT_FOR_LOAD; });
 }
 
 void IOP::wait_for_overlord_init_finish() {
   std::unique_lock<std::mutex> lk(iop_mutex);
-  if(overlord_init_done) return;
+  if (overlord_init_done)
+    return;
 
-  cv.wait(lk, [&]{return overlord_init_done;});
+  cv.wait(lk, [&] { return overlord_init_done; });
 }
 
 void IOP::signal_overlord_init_finish() {
@@ -57,7 +56,7 @@ void IOP::signal_overlord_init_finish() {
 }
 
 void IOP::reset_allocator() {
-  for(auto x : allocations) {
+  for (auto x : allocations) {
     free(x);
   }
   allocations.clear();
@@ -71,12 +70,12 @@ void* IOP::iop_alloc(int size) {
 
 void IOP::wait_run_iop() {
   std::unique_lock<std::mutex> lk(iters_mutex);
-  if(iop_iters_des > iop_iters_act) {
+  if (iop_iters_des > iop_iters_act) {
     iop_iters_act++;
     return;
   }
 
-  iop_run_cv.wait(lk, [&]{return iop_iters_des > iop_iters_act;});
+  iop_run_cv.wait(lk, [&] { return iop_iters_des > iop_iters_act; });
   iop_iters_act++;
 }
 
@@ -87,7 +86,7 @@ void IOP::kill_from_ee() {
 
 void IOP::signal_run_iop() {
   std::unique_lock<std::mutex> lk(iters_mutex);
-  iop_iters_des += 100; // todo, tune this
+  iop_iters_des += 100;  // todo, tune this
   iop_run_cv.notify_all();
 }
 
@@ -95,7 +94,7 @@ IOP::~IOP() {
   reset_allocator();
 }
 
-//void launch_iop(SystemThreadInterface& interfaces) {
+// void launch_iop(SystemThreadInterface& interface) {
 //  IOP iop;
 //
 //  printf("\n\n\n[IOP] Restart!\n");
@@ -140,14 +139,15 @@ IOP::~IOP() {
 //  iop.signal_overlord_init_finish();
 //
 //  // IOP Kernel loop
-//  while(!interfaces.get_want_exit() && !iop.want_exit) {
-//    // the IOP kernel just runs at full blast, so we only run the IOP when the EE is waiting on the IOP.
+//  while(!interface.get_want_exit() && !iop.want_exit) {
+//    // the IOP kernel just runs at full blast, so we only run the IOP when the EE is waiting on
+//    the IOP.
 //    // Each time the EE is waiting on the IOP, it will run an iteration of the IOP kernel.
 //    iop.wait_run_iop();
 //    iop.kernel.dispatchAll();
 //  }
 //
 //  // stop all threads in the iop kernel.
-//  // if the threads are not stopped nicely, we will deadlock on trying to destroy the kernel's condition variables.
-//  iop.kernel.shutdown();
+//  // if the threads are not stopped nicely, we will deadlock on trying to destroy the kernel's
+//  condition variables. iop.kernel.shutdown();
 //}
\ No newline at end of file
diff --git a/game/system/iop_thread.h b/game/system/iop_thread.h
index 96c42867ae..3b10645d6e 100644
--- a/game/system/iop_thread.h
+++ b/game/system/iop_thread.h
@@ -4,12 +4,7 @@
 #include "common/common_types.h"
 #include "IOP_Kernel.h"
 
-enum IOP_Status {
-  IOP_WAIT_FOR_LOAD,
-  IOP_OVERLORD_INIT,
-  IOP_OVERLORD_RUN,
-  IOP_OVERLORD_STOP
-};
+enum IOP_Status { IOP_WAIT_FOR_LOAD, IOP_OVERLORD_INIT, IOP_OVERLORD_RUN, IOP_OVERLORD_STOP };
 
 class IOP {
  public:
@@ -25,9 +20,7 @@ class IOP {
   void wait_run_iop();
   void kill_from_ee();
 
-  void set_ee_main_mem(u8* mem) {
-    ee_main_mem = mem;
-  }
+  void set_ee_main_mem(u8* mem) { ee_main_mem = mem; }
 
   IOP_Status status = IOP_WAIT_FOR_LOAD;
 
@@ -40,6 +33,7 @@ class IOP {
   u64 iop_iters_des = 0;
   u64 iop_iters_act = 0;
   bool want_exit = false;
+
  private:
   std::vector<void*> allocations;
   std::condition_variable cv;
diff --git a/goalc/CMakeLists.txt b/goalc/CMakeLists.txt
index 37507451f6..86a915cd0c 100644
--- a/goalc/CMakeLists.txt
+++ b/goalc/CMakeLists.txt
@@ -8,10 +8,11 @@ ELSE()
 ENDIF()
 add_subdirectory(emitter)
 
-add_executable(goalc main.cpp)
+add_executable(goalc main.cpp
+        compiler/Compiler.cpp)
 
 IF (WIN32)
   set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 ENDIF()
 
-target_link_libraries(goalc util goos)
\ No newline at end of file
+target_link_libraries(goalc util goos type_system)
\ No newline at end of file
diff --git a/goalc/compiler/Compiler.cpp b/goalc/compiler/Compiler.cpp
new file mode 100644
index 0000000000..b1d4ba1350
--- /dev/null
+++ b/goalc/compiler/Compiler.cpp
@@ -0,0 +1 @@
+#include "Compiler.h"
diff --git a/goalc/compiler/Compiler.h b/goalc/compiler/Compiler.h
new file mode 100644
index 0000000000..c9565aae14
--- /dev/null
+++ b/goalc/compiler/Compiler.h
@@ -0,0 +1,12 @@
+#ifndef JAK_COMPILER_H
+#define JAK_COMPILER_H
+
+#include "common/type_system/TypeSystem.h"
+
+class Compiler {
+ public:
+ private:
+  TypeSystem m_ts;
+};
+
+#endif  // JAK_COMPILER_H
diff --git a/goalc/emitter/CMakeLists.txt b/goalc/emitter/CMakeLists.txt
index fde45f4cb7..1d6cc0dc8f 100644
--- a/goalc/emitter/CMakeLists.txt
+++ b/goalc/emitter/CMakeLists.txt
@@ -1,3 +1,3 @@
 add_library(emitter
-        CodeTester.cpp
-        registers.cpp)
\ No newline at end of file
+        Register.cpp
+        CodeTester.cpp)
\ No newline at end of file
diff --git a/goalc/emitter/CodeTester.cpp b/goalc/emitter/CodeTester.cpp
index c40f6a8d52..4a07915d57 100644
--- a/goalc/emitter/CodeTester.cpp
+++ b/goalc/emitter/CodeTester.cpp
@@ -1,65 +1,131 @@
+/*!
+ * @file CodeTester.cpp
+ * The CodeTester is a utility to run the output of the compiler as part of a unit test.
+ * This is effective for tests which try all combinations of registers, etc.
+ *
+ * The CodeTester can't be used for tests requiring the full GOAL language/linking.
+ */
+
 #include <third-party/mman/mman.h>
 #include <cstdio>
+
+#include <sys/mman.h>
 #include "CodeTester.h"
-#include "Instruction.h"
 #include "IGen.h"
 
-namespace goal {
+namespace emitter {
 
-std::string CodeTester::dump_to_hex_string() {
+CodeTester::CodeTester() : m_info(RegisterInfo::make_register_info()) {}
+
+/*!
+ * Convert to a string for comparison against an assembler or tests.
+ */
+std::string CodeTester::dump_to_hex_string(bool nospace) {
   std::string result;
   char buff[32];
   for (int i = 0; i < code_buffer_size; i++) {
-    sprintf(buff, "%02x ", code_buffer[i]);
+    if (nospace) {
+      sprintf(buff, "%02X", code_buffer[i]);
+    } else {
+      sprintf(buff, "%02x ", code_buffer[i]);
+    }
+
     result += buff;
   }
 
   // remove trailing space
-  if (!result.empty()) {
+  if (!nospace && !result.empty()) {
     result.pop_back();
   }
   return result;
 }
 
+/*!
+ * Add an instruction to the buffer.
+ */
 void CodeTester::emit(const Instruction& instr) {
   code_buffer_size += instr.emit(code_buffer + code_buffer_size);
   assert(code_buffer_size <= code_buffer_capacity);
 }
 
-void CodeTester::emit_set_gpr_as_return(X86R gpr) {
-  assert(is_gpr(gpr));
-  emit(IGen::mov_gpr64_gpr64(RAX, gpr));
-}
-
+/*!
+ * Add a return instruction to the buffer.
+ */
 void CodeTester::emit_return() {
   emit(IGen::ret());
 }
 
+/*!
+ * Pop all GPRs off of the stack. Optionally exclude rax.
+ * Pops RSP always, which is weird, but doesn't cause issues.
+ */
 void CodeTester::emit_pop_all_gprs(bool exclude_rax) {
-  for(int i = 16; i-- > 0;) {
-    if(i != RAX || !exclude_rax) {
+  for (int i = 16; i-- > 0;) {
+    if (i != RAX || !exclude_rax) {
       emit(IGen::pop_gpr64(i));
     }
   }
 }
 
+/*!
+ * Push all GPRs onto the stack. Optionally exclude RAX.
+ * Pushes RSP always, which is weird, but doesn't cause issues.
+ */
 void CodeTester::emit_push_all_gprs(bool exclude_rax) {
   for (int i = 0; i < 16; i++) {
-    if(i != RAX || !exclude_rax) {
+    if (i != RAX || !exclude_rax) {
       emit(IGen::push_gpr64(i));
     }
-
   }
 }
 
+/*!
+ * Push all xmm registers (all 128-bits) to the stack.
+ */
+void CodeTester::emit_push_all_xmms() {
+  emit(IGen::sub_gpr64_imm8s(RSP, 8));
+  for (int i = 0; i < 16; i++) {
+    emit(IGen::sub_gpr64_imm8s(RSP, 16));
+    emit(IGen::store128_gpr64_xmm128(RSP, XMM0 + i));
+  }
+}
+
+/*!
+ * Pop all xmm registers (all 128-bits) from the stack
+ */
+void CodeTester::emit_pop_all_xmms() {
+  for (int i = 0; i < 16; i++) {
+    emit(IGen::load128_xmm128_gpr64(XMM0 + i, RSP));
+    emit(IGen::add_gpr64_imm8s(RSP, 16));
+  }
+  emit(IGen::add_gpr64_imm8s(RSP, 8));
+}
+
+/*!
+ * Remove everything from the code buffer
+ */
 void CodeTester::clear() {
   code_buffer_size = 0;
 }
 
+/*!
+ * Execute the buffered code with no arguments, return the value of RAX.
+ */
 u64 CodeTester::execute() {
   return ((u64(*)())code_buffer)();
 }
 
+/*!
+ * Execute code buffer with arguments. Use get_c_abi_arg to figure out which registers the
+ * arguments will appear in (will handle windows/linux differences)
+ */
+u64 CodeTester::execute(u64 in0, u64 in1, u64 in2, u64 in3) {
+  return ((u64(*)(u64, u64, u64, u64))code_buffer)(in0, in1, in2, in3);
+}
+
+/*!
+ * Allocate a code buffer of the given size.
+ */
 void CodeTester::init_code_buffer(int capacity) {
   code_buffer = (u8*)mmap(nullptr, capacity, PROT_EXEC | PROT_READ | PROT_WRITE,
                           MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
@@ -77,5 +143,4 @@ CodeTester::~CodeTester() {
     munmap(code_buffer, code_buffer_capacity);
   }
 }
-
-}  // namespace goal
\ No newline at end of file
+}  // namespace emitter
\ No newline at end of file
diff --git a/goalc/emitter/CodeTester.h b/goalc/emitter/CodeTester.h
index 4ea7eb95d3..ee174ac659 100644
--- a/goalc/emitter/CodeTester.h
+++ b/goalc/emitter/CodeTester.h
@@ -1,37 +1,131 @@
 /*!
- * @file CodeTester
- * CodeTester is a utility which allows small segments of x86 code to be run, for the purpose of
- * testing the compiler's code emitter.  It is not suitable for testing compiled GOAL code.
+ * @file CodeTester.h
+ * The CodeTester is a utility to run the output of the compiler as part of a unit test.
+ * This is effective for tests which try all combinations of registers, etc.
+ *
+ * The CodeTester can't be used for tests requiring the full GOAL language/linking.
  */
 
-#ifndef JAK1_CODETESTER_H
-#define JAK1_CODETESTER_H
+#ifndef JAK_CODETESTER_H
+#define JAK_CODETESTER_H
 
 #include <string>
 #include "common/common_types.h"
-#include "registers.h"
+#include "Register.h"
 #include "Instruction.h"
 
-namespace goal {
+namespace emitter {
 class CodeTester {
  public:
-  std::string dump_to_hex_string();
+  CodeTester();
+  std::string dump_to_hex_string(bool nospace = false);
   void init_code_buffer(int capacity);
   void emit_push_all_gprs(bool exclude_rax = false);
   void emit_pop_all_gprs(bool exclude_rax = false);
+  void emit_push_all_xmms();
+  void emit_pop_all_xmms();
   void emit_return();
-  void emit_set_gpr_as_return(X86R gpr);
   void emit(const Instruction& instr);
   u64 execute();
+  u64 execute(u64 in0, u64 in1, u64 in2, u64 in3);
+
+  /*!
+   * Execute the function, get the return value in RAX, convert to a T, and return it.
+   */
+  template <typename T>
+  T execute_ret(u64 in0, u64 in1, u64 in2, u64 in3) {
+    u64 result_u64 = ((u64(*)(u64, u64, u64, u64))code_buffer)(in0, in1, in2, in3);
+    T result_T;
+    memcpy(&result_T, &result_u64, sizeof(T));
+    return result_T;
+  }
+
+  /*!
+   * Add data to the code buffer.
+   */
+  template <typename T>
+  int emit_data(T x) {
+    auto ret = code_buffer_size;
+    assert(int(sizeof(T)) + code_buffer_size <= code_buffer_capacity);
+    memcpy(code_buffer + code_buffer_size, &x, sizeof(T));
+    code_buffer_size += sizeof(T);
+    return ret;
+  }
+
+  /*!
+   * Should allow emitter tests which run code to do the right thing on windows.
+   */
+  Register get_c_abi_arg_reg(int i) {
+#ifdef _WIN32
+    switch (i) {
+      case 0:
+        return RCX;
+      case 1:
+        return RDX;
+      case 2:
+        return R8;
+      case 3:
+        return R9;
+      default:
+        assert(false);
+    }
+#else
+    switch (i) {
+      case 0:
+        return RDI;
+      case 1:
+        return RSI;
+      case 2:
+        return RDX;
+      case 3:
+        return RCX;
+      default:
+        assert(false);
+    }
+#endif
+  }
+
+  /*!
+   * Get the name of the given register, for debugging.
+   */
+  std::string reg_name(Register x) { return m_info.get_info(x).name; }
+
+  /*!
+   * Get number of bytes currently in use (offset of the next thing to be added)
+   */
+  int size() const { return code_buffer_size; }
+  const u8* data() const { return code_buffer; }
+
+  /*!
+   * Write over existing data at the given offset.
+   */
+  template <typename T>
+  void write(T x, int at) {
+    assert(at >= 0);
+    assert(int(sizeof(T)) + at <= code_buffer_capacity);
+    memcpy(code_buffer + at, &x, sizeof(T));
+  }
+
+  /*!
+   * Read existing data at the given offset.
+   */
+  template <typename T>
+  T read(int at) {
+    assert(at >= 0);
+    assert(int(sizeof(T)) + at <= code_buffer_capacity);
+    T result;
+    memcpy(&result, code_buffer + at, sizeof(T));
+    return result;
+  }
+
   void clear();
   ~CodeTester();
+
  private:
-
-
   int code_buffer_size = 0;
   int code_buffer_capacity = 0;
   u8* code_buffer = nullptr;
+  RegisterInfo m_info;
 };
-}  // namespace goal
-
-#endif  // JAK1_CODETESTER_H
+}  // namespace emitter
+#endif  // JAK_CODETESTER_H
diff --git a/goalc/emitter/IGen.h b/goalc/emitter/IGen.h
index 7c1a206e7f..978329adf6 100644
--- a/goalc/emitter/IGen.h
+++ b/goalc/emitter/IGen.h
@@ -1,56 +1,58 @@
-#ifndef JAK1_IGEN_H
-#define JAK1_IGEN_H
+#ifndef JAK_IGEN_H
+#define JAK_IGEN_H
 
-#include <stdexcept>
+#include <cassert>
+#include "Register.h"
 #include "Instruction.h"
-#include "registers.h"
 
-namespace goal {
+namespace emitter {
 class IGen {
  public:
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   //   MOVES
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   /*!
-   * mov gpr, gpr, 64 bits
+   * Move data from src to dst. Moves all 64-bits of the GPR.
    */
-  static Instruction mov_gpr64_gpr64(uint8_t dst, uint8_t src) {
-    assert(is_gpr(dst));
-    assert(is_gpr(src));
+  static Instruction mov_gpr64_gpr64(Register dst, Register src) {
+    assert(dst.is_gpr());
+    assert(src.is_gpr());
     Instruction instr(0x89);
-    instr.set_modrm_and_rex(src, dst, 3, true);
+    instr.set_modrm_and_rex(src.hw_id(), dst.hw_id(), 3, true);
     return instr;
   }
 
   /*!
    * Move a 64-bit constant into a register.
    */
-  static Instruction mov_gpr64_u64(uint8_t dst, uint64_t val) {
-    assert(is_gpr(dst));
+  static Instruction mov_gpr64_u64(Register dst, uint64_t val) {
+    assert(dst.is_gpr());
     bool rex_b = false;
-    if (dst >= 8) {
-      dst -= 8;
+    auto dst_hw_id = dst.hw_id();
+    if (dst_hw_id >= 8) {
+      dst_hw_id -= 8;
       rex_b = true;
     }
-    Instruction instr(0xb8 + dst);
+    Instruction instr(0xb8 + dst_hw_id);
     instr.set(REX(true, false, false, rex_b));
     instr.set(Imm(8, val));
     return instr;
   }
 
   /*!
-   * Move a 32-bit constant into a register.
+   * Move a 32-bit constant into a register. Zeros the upper 32 bits.
    */
-  static Instruction mov_gpr64_u32(uint8_t dst, uint64_t val) {
+  static Instruction mov_gpr64_u32(Register dst, uint64_t val) {
     assert(val <= UINT32_MAX);
-    assert(is_gpr(dst));
+    assert(dst.is_gpr());
+    auto dst_hw_id = dst.hw_id();
     bool rex_b = false;
-    if (dst >= 8) {
-      dst -= 8;
+    if (dst_hw_id >= 8) {
+      dst_hw_id -= 8;
       rex_b = true;
     }
 
-    Instruction instr(0xb8 + dst);
+    Instruction instr(0xb8 + dst_hw_id);
     if (rex_b) {
       instr.set(REX(false, false, false, rex_b));
     }
@@ -59,689 +61,1686 @@ class IGen {
   }
 
   /*!
-   * Move a signed 32-bit constant into a register.
+   * Move a signed 32-bit constant into a register. Sign extends for the upper 32 bits.
    * When possible prefer mov_gpr64_u32. (use this only for negative values...)
    * This is always bigger than mov_gpr64_u32, but smaller than a mov_gpr_u64.
    */
-  static Instruction mov_gpr64_s32(uint8_t dst, int64_t val) {
+  static Instruction mov_gpr64_s32(Register dst, int64_t val) {
     assert(val >= INT32_MIN && val <= INT32_MAX);
-    assert(is_gpr(dst));
+    assert(dst.is_gpr());
     Instruction instr(0xc7);
-    instr.set_modrm_and_rex(0, dst, 3, true);
+    instr.set_modrm_and_rex(0, dst.hw_id(), 3, true);
     instr.set(Imm(4, val));
     return instr;
   }
 
-    /*!
-     * Move 32-bits of xmm to 32 bits of gpr (no sign extension).
-     */
-    static Instruction movd_gpr32_xmm32(uint8_t dst, uint8_t src) {
-      assert(is_gpr(dst));
-      assert(is_xmm(src));
-      Instruction instr(0x66);
-      instr.set_op2(0x0f);
-      instr.set_op3(0x7e);
-      instr.set_modrm_and_rex(xmm_to_id(src), dst, 3, false);
-      instr.swap_op0_rex();
-      return instr;
-    }
+  /*!
+   * Move 32-bits of xmm to 32 bits of gpr (no sign extension).
+   */
+  static Instruction movd_gpr32_xmm32(Register dst, Register src) {
+    assert(dst.is_gpr());
+    assert(src.is_xmm());
+    Instruction instr(0x66);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x7e);
+    instr.set_modrm_and_rex(src.hw_id(), dst.hw_id(), 3, false);
+    instr.swap_op0_rex();
+    return instr;
+  }
 
-    /*!
-     * Move 32-bits of gpr to 32-bits of xmm (no sign extenion)
-     */
-    static Instruction movd_xmm32_gpr32(uint8_t dst, uint8_t src) {
-      assert(is_xmm(dst));
-      assert(is_gpr(src));
-      Instruction instr(0x66);
-      instr.set_op2(0x0f);
-      instr.set_op3(0x6e);
-      instr.set_modrm_and_rex(dst, xmm_to_id(src), 3, false);
-      instr.swap_op0_rex();
-      return instr;
-    }
+  /*!
+   * Move 32-bits of gpr to 32-bits of xmm (no sign extension)
+   */
+  static Instruction movd_xmm32_gpr32(Register dst, Register src) {
+    assert(dst.is_xmm());
+    assert(src.is_gpr());
+    Instruction instr(0x66);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x6e);
+    instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, false);
+    instr.swap_op0_rex();
+    return instr;
+  }
 
-    /*!
-     * Move 32-bits between xmm's
-     */
-    static Instruction mov_xmm32_xmm32(uint8_t dst, uint8_t src) {
-      assert(is_xmm(dst));
-      assert(is_xmm(src));
-      Instruction instr(0xf3);
-      instr.set_op2(0x0f);
-      instr.set_op3(0x10);
-      instr.set_modrm_and_rex(xmm_to_id(dst), xmm_to_id(src), 3, false);
-      return instr;
+  /*!
+   * Move 32-bits between xmm's
+   */
+  static Instruction mov_xmm32_xmm32(Register dst, Register src) {
+    assert(dst.is_xmm());
+    assert(src.is_xmm());
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x10);
+    instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, false);
+    return instr;
+  }
+
+  // todo - GPR64 -> XMM64 (zext)
+  // todo - XMM -> GPR64
+  // todo - XMM128 - XMM128
+
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  //   GOAL Loads and Stores
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  /*!
+   * movsx dst, BYTE PTR [addr1 + addr2]
+   * addr1 and addr2 have to be different registers.
+   * Cannot use rsp.
+   */
+  static Instruction load8s_gpr64_gpr64_plus_gpr64(Register dst, Register addr1, Register addr2) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    Instruction instr(0xf);
+    instr.set_op2(0xbe);
+    instr.set_modrm_and_rex_for_reg_plus_reg_addr(dst.hw_id(), addr1.hw_id(), addr2.hw_id(), true,
+                                                  false);
+    return instr;
+  }
+
+  static Instruction store8_gpr64_gpr64_plus_gpr64(Register addr1, Register addr2, Register value) {
+    assert(value.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    Instruction instr(0x88);
+    instr.set_modrm_and_rex_for_reg_plus_reg_addr(value.hw_id(), addr1.hw_id(), addr2.hw_id());
+    if (value.id() > RBX) {
+      instr.add_rex();
     }
-  //
-  //  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  //  //   LOADS n' STORES
-  //  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  //
-  //  /*!
-  //   * Store 8-bits from register into a memory location that is the sum of a 64-bit register
-  //   * and signed 32-bit offset.
-  //   */
-  //  static Instruction store8_r64off32s_gpr8(uint8_t dst_reg, int32_t offset, uint8_t src_reg) {
-  //    Instruction instr(0x88);
-  //    instr.set_modrm_and_rex_for_addr(src_reg, dst_reg, 2, false);
-  //    instr.set_disp(Imm(4, offset));
-  //    if (src_reg > int(X86R::RBX)) {
-  //      instr.add_rex();
-  //    }
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Store 16-bits from register into a memory location that is the sum of a 64-bit register
-  //   * and signed 32-bit offset.
-  //   */
-  //  static Instruction store16_r64off32s_gpr16(uint8_t dst_reg, int32_t offset, uint8_t src_reg) {
-  //    Instruction instr(0x66);
-  //    instr.set_op2(0x89);
-  //    instr.set_modrm_and_rex_for_addr(src_reg, dst_reg, 2, false);
-  //    instr.set_disp(Imm(4, offset));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Store 32-bits from register into a memory location that is the sum of a 64-bit register
-  //   * and signed 32-bit offset.
-  //   */
-  //  static Instruction store32_r64off32s_gpr32(uint8_t dst_reg, int32_t offset, uint8_t src_reg) {
-  //    Instruction instr(0x89);
-  //    instr.set_modrm_and_rex_for_addr(src_reg, dst_reg, 2, false);
-  //    instr.set_disp(Imm(4, offset));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Store 64-bits from gpr into memory located at 64-bit reg + 32-bit signed offset.
-  //   */
-  //  static Instruction store64_r64off32s_gpr64(uint8_t dst_reg, int32_t offset, uint8_t src_reg) {
-  //    Instruction instr(0x89);
-  //    instr.set_modrm_rex_sib_for_reg_reg_disp32(src_reg, 2, dst_reg, true);
-  //    instr.set_disp(Imm(4, offset));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Load 8-bits from memory (at address of 64-bit reg + 32-bit signed offset) into gpr (zero
-  //   * extended)
-  //   */
-  //  static Instruction load16_gpr8z_r64off32s(uint8_t dst, uint8_t src, int32_t offset) {
-  //    Instruction instr(0x0f);
-  //    instr.set_op2(0xb6);
-  //    instr.set_modrm_rex_sib_for_reg_reg_disp32(dst, 2, src, true);
-  //    instr.set_disp(Imm(4, offset));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Load 16-bits from memory (at address of 64-bit reg + 32-bit signed offset) into gpr (zero
-  //   * extended)
-  //   */
-  //  static Instruction load16_gpr16z_r64off32s(uint8_t dst, uint8_t src, int32_t offset) {
-  //    Instruction instr(0x0f);
-  //    instr.set_op2(0xb7);
-  //    instr.set_modrm_rex_sib_for_reg_reg_disp32(dst, 2, src, true);
-  //    instr.set_disp(Imm(4, offset));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Load 16-bits from memory (at address of 64-bit reg + 32-bit signed offset) into gpr (sign
-  //   * extended)
-  //   */
-  //  static Instruction load16_gpr16s_r64off32s(uint8_t dst, uint8_t src, int32_t offset) {
-  //    Instruction instr(0x0f);
-  //    instr.set_op2(0xbf);
-  //    instr.set_modrm_rex_sib_for_reg_reg_disp32(dst, 2, src, true);
-  //    instr.set_disp(Imm(4, offset));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Load 32-bits from memory (at address of 64-bit reg + 32-bit signed offset) into gpr.
-  //   * Use the sext flag to enable sign extension.
-  //   */
-  //  static Instruction load32_gpr32sz_r64off32s(uint8_t dst_reg,
-  //                                              int32_t offset,
-  //                                              uint8_t src_reg,
-  //                                              bool sext = false) {
-  //    Instruction instr(0x8b);
-  //    if (sext) {
-  //      instr.op = 0x63;
-  //    }
-  //    instr.set_modrm_rex_sib_for_reg_reg_disp32(dst_reg, 2, src_reg, sext);
-  //    instr.set_disp(Imm(4, offset));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Load 64-bits from memory located at 64-bit reg + 32-bit signed offset into gpr
-  //   */
-  //  static Instruction load64_gpr64_r64off32s(uint8_t dst_reg, int32_t offset, uint8_t src_reg) {
-  //    Instruction instr(0x8b);
-  //    instr.set_modrm_rex_sib_for_reg_reg_disp32(dst_reg, 2, src_reg, true);
-  //    instr.set_disp(Imm(4, offset));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Load 32-bits form memory located at 64-bit reg + 32-bit signed offset into xmm (32-bits)
-  //   * movss
-  //   */
-  //  static Instruction load32_xmm32_r64off32s(uint8_t dst, uint8_t src, int32_t offset) {
-  //    Instruction instr(0xf3);
-  //    instr.set_op2(0x0f);
-  //    instr.set_op3(0x10);
-  //    instr.set_modrm_rex_sib_for_reg_reg_disp32(dst, 2, src, false);
-  //    instr.set_disp(Imm(4, offset));
-  //    instr.swap_op0_rex();
-  //    return instr;
-  //  }
+    return instr;
+  }
+
+  static Instruction load8s_gpr64_gpr64_plus_gpr64_plus_s8(Register dst,
+                                                           Register addr1,
+                                                           Register addr2,
+                                                           s64 offset) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT8_MIN && offset <= INT8_MAX);
+    Instruction instr(0xf);
+    instr.set_op2(0xbe);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s8(dst.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                     offset, true);
+    return instr;
+  }
+
+  static Instruction store8_gpr64_gpr64_plus_gpr64_plus_s8(Register addr1,
+                                                           Register addr2,
+                                                           Register value,
+                                                           s64 offset) {
+    assert(value.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT8_MIN && offset <= INT8_MAX);
+    Instruction instr(0x88);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s8(value.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                     offset, false);
+    if (value.id() > RBX) {
+      instr.add_rex();
+    }
+    return instr;
+  }
+
+  static Instruction load8s_gpr64_gpr64_plus_gpr64_plus_s32(Register dst,
+                                                            Register addr1,
+                                                            Register addr2,
+                                                            s64 offset) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0xf);
+    instr.set_op2(0xbe);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s32(dst.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                      offset, true);
+    return instr;
+  }
+
+  static Instruction store8_gpr64_gpr64_plus_gpr64_plus_s32(Register addr1,
+                                                            Register addr2,
+                                                            Register value,
+                                                            s64 offset) {
+    assert(value.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x88);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s32(value.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                      offset, false);
+    if (value.id() > RBX) {
+      instr.add_rex();
+    }
+    return instr;
+  }
+
+  /*!
+   * movzx dst, BYTE PTR [addr1 + addr2]
+   * addr1 and addr2 have to be different registers.
+   * Cannot use rsp.
+   */
+  static Instruction load8u_gpr64_gpr64_plus_gpr64(Register dst, Register addr1, Register addr2) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    Instruction instr(0xf);
+    instr.set_op2(0xb6);
+    instr.set_modrm_and_rex_for_reg_plus_reg_addr(dst.hw_id(), addr1.hw_id(), addr2.hw_id(), true,
+                                                  false);
+    return instr;
+  }
+
+  static Instruction load8u_gpr64_gpr64_plus_gpr64_plus_s8(Register dst,
+                                                           Register addr1,
+                                                           Register addr2,
+                                                           s64 offset) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT8_MIN && offset <= INT8_MAX);
+    Instruction instr(0xf);
+    instr.set_op2(0xb6);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s8(dst.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                     offset, true);
+    return instr;
+  }
+
+  static Instruction load8u_gpr64_gpr64_plus_gpr64_plus_s32(Register dst,
+                                                            Register addr1,
+                                                            Register addr2,
+                                                            s64 offset) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0xf);
+    instr.set_op2(0xb6);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s32(dst.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                      offset, true);
+    return instr;
+  }
+
+  /*!
+   * movsx dst, WORD PTR [addr1 + addr2]
+   * addr1 and addr2 have to be different registers.
+   * Cannot use rsp.
+   */
+  static Instruction load16s_gpr64_gpr64_plus_gpr64(Register dst, Register addr1, Register addr2) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    Instruction instr(0xf);
+    instr.set_op2(0xbf);
+    instr.set_modrm_and_rex_for_reg_plus_reg_addr(dst.hw_id(), addr1.hw_id(), addr2.hw_id(), true,
+                                                  false);
+    return instr;
+  }
+
+  static Instruction store16_gpr64_gpr64_plus_gpr64(Register addr1,
+                                                    Register addr2,
+                                                    Register value) {
+    assert(value.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    Instruction instr(0x66);
+    instr.set_op2(0x89);
+    instr.set_modrm_and_rex_for_reg_plus_reg_addr(value.hw_id(), addr1.hw_id(), addr2.hw_id());
+    instr.swap_op0_rex();  // why?????
+    return instr;
+  }
+
+  static Instruction store16_gpr64_gpr64_plus_gpr64_plus_s8(Register addr1,
+                                                            Register addr2,
+                                                            Register value,
+                                                            s64 offset) {
+    assert(value.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT8_MIN && offset <= INT8_MAX);
+    Instruction instr(0x66);
+    instr.set_op2(0x89);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s8(value.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                     offset, false);
+    instr.swap_op0_rex();  // why?????
+    return instr;
+  }
+
+  static Instruction store16_gpr64_gpr64_plus_gpr64_plus_s32(Register addr1,
+                                                             Register addr2,
+                                                             Register value,
+                                                             s64 offset) {
+    assert(value.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x66);
+    instr.set_op2(0x89);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s32(value.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                      offset, false);
+    instr.swap_op0_rex();  // why?????
+    return instr;
+  }
+
+  static Instruction load16s_gpr64_gpr64_plus_gpr64_plus_s8(Register dst,
+                                                            Register addr1,
+                                                            Register addr2,
+                                                            s64 offset) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT8_MIN && offset <= INT8_MAX);
+    Instruction instr(0xf);
+    instr.set_op2(0xbf);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s8(dst.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                     offset, true);
+    return instr;
+  }
+
+  static Instruction load16s_gpr64_gpr64_plus_gpr64_plus_s32(Register dst,
+                                                             Register addr1,
+                                                             Register addr2,
+                                                             s64 offset) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0xf);
+    instr.set_op2(0xbf);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s32(dst.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                      offset, true);
+    return instr;
+  }
+
+  /*!
+   * movzx dst, WORD PTR [addr1 + addr2]
+   * addr1 and addr2 have to be different registers.
+   * Cannot use rsp.
+   */
+  static Instruction load16u_gpr64_gpr64_plus_gpr64(Register dst, Register addr1, Register addr2) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    Instruction instr(0xf);
+    instr.set_op2(0xb7);
+    instr.set_modrm_and_rex_for_reg_plus_reg_addr(dst.hw_id(), addr1.hw_id(), addr2.hw_id(), true,
+                                                  false);
+    return instr;
+  }
+
+  static Instruction load16u_gpr64_gpr64_plus_gpr64_plus_s8(Register dst,
+                                                            Register addr1,
+                                                            Register addr2,
+                                                            s64 offset) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT8_MIN && offset <= INT8_MAX);
+    Instruction instr(0xf);
+    instr.set_op2(0xb7);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s8(dst.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                     offset, true);
+    return instr;
+  }
+
+  static Instruction load16u_gpr64_gpr64_plus_gpr64_plus_s32(Register dst,
+                                                             Register addr1,
+                                                             Register addr2,
+                                                             s64 offset) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0xf);
+    instr.set_op2(0xb7);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s32(dst.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                      offset, true);
+    return instr;
+  }
+
+  /*!
+   * movsxd dst, DWORD PTR [addr1 + addr2]
+   * addr1 and addr2 have to be different registers.
+   * Cannot use rsp.
+   */
+  static Instruction load32s_gpr64_gpr64_plus_gpr64(Register dst, Register addr1, Register addr2) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    Instruction instr(0x63);
+    instr.set_modrm_and_rex_for_reg_plus_reg_addr(dst.hw_id(), addr1.hw_id(), addr2.hw_id(), true);
+    return instr;
+  }
+
+  static Instruction store32_gpr64_gpr64_plus_gpr64(Register addr1,
+                                                    Register addr2,
+                                                    Register value) {
+    assert(value.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    Instruction instr(0x89);
+    instr.set_modrm_and_rex_for_reg_plus_reg_addr(value.hw_id(), addr1.hw_id(), addr2.hw_id());
+    return instr;
+  }
+
+  static Instruction load32s_gpr64_gpr64_plus_gpr64_plus_s8(Register dst,
+                                                            Register addr1,
+                                                            Register addr2,
+                                                            s64 offset) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT8_MIN && offset <= INT8_MAX);
+    Instruction instr(0x63);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s8(dst.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                     offset, true);
+    return instr;
+  }
+
+  static Instruction store32_gpr64_gpr64_plus_gpr64_plus_s8(Register addr1,
+                                                            Register addr2,
+                                                            Register value,
+                                                            s64 offset) {
+    assert(value.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT8_MIN && offset <= INT8_MAX);
+    Instruction instr(0x89);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s8(value.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                     offset, false);
+    return instr;
+  }
+
+  static Instruction load32s_gpr64_gpr64_plus_gpr64_plus_s32(Register dst,
+                                                             Register addr1,
+                                                             Register addr2,
+                                                             s64 offset) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x63);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s32(dst.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                      offset, true);
+    return instr;
+  }
+
+  static Instruction store32_gpr64_gpr64_plus_gpr64_plus_s32(Register addr1,
+                                                             Register addr2,
+                                                             Register value,
+                                                             s64 offset) {
+    assert(value.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x89);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s32(value.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                      offset, false);
+    return instr;
+  }
+
+  /*!
+   * movzxd dst, DWORD PTR [addr1 + addr2]
+   * addr1 and addr2 have to be different registers.
+   * Cannot use rsp.
+   */
+  static Instruction load32u_gpr64_gpr64_plus_gpr64(Register dst, Register addr1, Register addr2) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    Instruction instr(0x8b);
+    instr.set_modrm_and_rex_for_reg_plus_reg_addr(dst.hw_id(), addr1.hw_id(), addr2.hw_id());
+    return instr;
+  }
+
+  static Instruction load32u_gpr64_gpr64_plus_gpr64_plus_s8(Register dst,
+                                                            Register addr1,
+                                                            Register addr2,
+                                                            s64 offset) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT8_MIN && offset <= INT8_MAX);
+    Instruction instr(0x8b);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s8(dst.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                     offset, false);
+    return instr;
+  }
+
+  static Instruction load32u_gpr64_gpr64_plus_gpr64_plus_s32(Register dst,
+                                                             Register addr1,
+                                                             Register addr2,
+                                                             s64 offset) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x8b);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s32(dst.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                      offset, false);
+    return instr;
+  }
+
+  /*!
+   * mov dst, QWORD PTR [addr1 + addr2]
+   * addr1 and addr2 have to be different registers.
+   * Cannot use rsp.
+   */
+  static Instruction load64_gpr64_gpr64_plus_gpr64(Register dst, Register addr1, Register addr2) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    Instruction instr(0x8b);
+    instr.set_modrm_and_rex_for_reg_plus_reg_addr(dst.hw_id(), addr1.hw_id(), addr2.hw_id(), true);
+    return instr;
+  }
+
+  static Instruction store64_gpr64_gpr64_plus_gpr64(Register addr1,
+                                                    Register addr2,
+                                                    Register value) {
+    assert(value.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    Instruction instr(0x89);
+    instr.set_modrm_and_rex_for_reg_plus_reg_addr(value.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                  true);
+    return instr;
+  }
+
+  static Instruction load64_gpr64_gpr64_plus_gpr64_plus_s8(Register dst,
+                                                           Register addr1,
+                                                           Register addr2,
+                                                           s64 offset) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT8_MIN && offset <= INT8_MAX);
+    Instruction instr(0x8b);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s8(dst.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                     offset, true);
+    return instr;
+  }
+
+  static Instruction store64_gpr64_gpr64_plus_gpr64_plus_s8(Register addr1,
+                                                            Register addr2,
+                                                            Register value,
+                                                            s64 offset) {
+    assert(value.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT8_MIN && offset <= INT8_MAX);
+    Instruction instr(0x89);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s8(value.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                     offset, true);
+    return instr;
+  }
+
+  static Instruction load64_gpr64_gpr64_plus_gpr64_plus_s32(Register dst,
+                                                            Register addr1,
+                                                            Register addr2,
+                                                            s64 offset) {
+    assert(dst.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x8b);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s32(dst.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                      offset, true);
+    return instr;
+  }
+
+  static Instruction store64_gpr64_gpr64_plus_gpr64_plus_s32(Register addr1,
+                                                             Register addr2,
+                                                             Register value,
+                                                             s64 offset) {
+    assert(value.is_gpr());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(addr1 != addr2);
+    assert(addr1 != RSP);
+    assert(addr2 != RSP);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x89);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s32(value.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                      offset, true);
+    return instr;
+  }
+
+  static Instruction store_goal_gpr(Register addr,
+                                    Register value,
+                                    Register off,
+                                    int offset,
+                                    int size) {
+    switch (size) {
+      case 1:
+        if (offset == 0) {
+          return store8_gpr64_gpr64_plus_gpr64(addr, off, value);
+        } else if (offset >= INT8_MIN && offset <= INT8_MAX) {
+          return store8_gpr64_gpr64_plus_gpr64_plus_s8(addr, off, value, offset);
+        } else if (offset >= INT32_MIN && offset <= INT32_MAX) {
+          return store8_gpr64_gpr64_plus_gpr64_plus_s32(addr, off, value, offset);
+        } else {
+          assert(false);
+        }
+      case 2:
+        if (offset == 0) {
+          return store16_gpr64_gpr64_plus_gpr64(addr, off, value);
+        } else if (offset >= INT8_MIN && offset <= INT8_MAX) {
+          return store16_gpr64_gpr64_plus_gpr64_plus_s8(addr, off, value, offset);
+        } else if (offset >= INT32_MIN && offset <= INT32_MAX) {
+          return store16_gpr64_gpr64_plus_gpr64_plus_s32(addr, off, value, offset);
+        } else {
+          assert(false);
+        }
+      case 4:
+        if (offset == 0) {
+          return store32_gpr64_gpr64_plus_gpr64(addr, off, value);
+        } else if (offset >= INT8_MIN && offset <= INT8_MAX) {
+          return store32_gpr64_gpr64_plus_gpr64_plus_s8(addr, off, value, offset);
+        } else if (offset >= INT32_MIN && offset <= INT32_MAX) {
+          return store32_gpr64_gpr64_plus_gpr64_plus_s32(addr, off, value, offset);
+        } else {
+          assert(false);
+        }
+      case 8:
+        if (offset == 0) {
+          return store64_gpr64_gpr64_plus_gpr64(addr, off, value);
+        } else if (offset >= INT8_MIN && offset <= INT8_MAX) {
+          return store64_gpr64_gpr64_plus_gpr64_plus_s8(addr, off, value, offset);
+        } else if (offset >= INT32_MIN && offset <= INT32_MAX) {
+          return store64_gpr64_gpr64_plus_gpr64_plus_s32(addr, off, value, offset);
+        } else {
+          assert(false);
+        }
+      default:
+        assert(false);
+    }
+  }
+
+  /*!
+   * Load memory at addr + offset, where addr is a GOAL pointer and off is the offset register.
+   * This will pick the appropriate fancy addressing mode instruction.
+   */
+  static Instruction load_goal_gpr(Register dst,
+                                   Register addr,
+                                   Register off,
+                                   int offset,
+                                   int size,
+                                   bool sign_extend) {
+    switch (size) {
+      case 1:
+        if (offset == 0) {
+          if (sign_extend) {
+            return load8s_gpr64_gpr64_plus_gpr64(dst, addr, off);
+          } else {
+            return load8u_gpr64_gpr64_plus_gpr64(dst, addr, off);
+          }
+        } else if (offset >= INT8_MIN && offset <= INT8_MAX) {
+          if (sign_extend) {
+            return load8s_gpr64_gpr64_plus_gpr64_plus_s8(dst, addr, off, offset);
+          } else {
+            return load8u_gpr64_gpr64_plus_gpr64_plus_s8(dst, addr, off, offset);
+          }
+        } else if (offset >= INT32_MIN && offset <= INT32_MAX) {
+          if (sign_extend) {
+            return load8s_gpr64_gpr64_plus_gpr64_plus_s32(dst, addr, off, offset);
+          } else {
+            return load8u_gpr64_gpr64_plus_gpr64_plus_s32(dst, addr, off, offset);
+          }
+        } else {
+          assert(false);
+        }
+      case 2:
+        if (offset == 0) {
+          if (sign_extend) {
+            return load16s_gpr64_gpr64_plus_gpr64(dst, addr, off);
+          } else {
+            return load16u_gpr64_gpr64_plus_gpr64(dst, addr, off);
+          }
+        } else if (offset >= INT8_MIN && offset <= INT8_MAX) {
+          if (sign_extend) {
+            return load16s_gpr64_gpr64_plus_gpr64_plus_s8(dst, addr, off, offset);
+          } else {
+            return load16u_gpr64_gpr64_plus_gpr64_plus_s8(dst, addr, off, offset);
+          }
+        } else if (offset >= INT32_MIN && offset <= INT32_MAX) {
+          if (sign_extend) {
+            return load16s_gpr64_gpr64_plus_gpr64_plus_s32(dst, addr, off, offset);
+          } else {
+            return load16u_gpr64_gpr64_plus_gpr64_plus_s32(dst, addr, off, offset);
+          }
+        } else {
+          assert(false);
+        }
+      case 4:
+        if (offset == 0) {
+          if (sign_extend) {
+            return load32s_gpr64_gpr64_plus_gpr64(dst, addr, off);
+          } else {
+            return load32u_gpr64_gpr64_plus_gpr64(dst, addr, off);
+          }
+        } else if (offset >= INT8_MIN && offset <= INT8_MAX) {
+          if (sign_extend) {
+            return load32s_gpr64_gpr64_plus_gpr64_plus_s8(dst, addr, off, offset);
+          } else {
+            return load32u_gpr64_gpr64_plus_gpr64_plus_s8(dst, addr, off, offset);
+          }
+        } else if (offset >= INT32_MIN && offset <= INT32_MAX) {
+          if (sign_extend) {
+            return load32s_gpr64_gpr64_plus_gpr64_plus_s32(dst, addr, off, offset);
+          } else {
+            return load32u_gpr64_gpr64_plus_gpr64_plus_s32(dst, addr, off, offset);
+          }
+        } else {
+          assert(false);
+        }
+      case 8:
+        if (offset == 0) {
+          return load64_gpr64_gpr64_plus_gpr64(dst, addr, off);
+
+        } else if (offset >= INT8_MIN && offset <= INT8_MAX) {
+          return load64_gpr64_gpr64_plus_gpr64_plus_s8(dst, addr, off, offset);
+
+        } else if (offset >= INT32_MIN && offset <= INT32_MAX) {
+          return load64_gpr64_gpr64_plus_gpr64_plus_s32(dst, addr, off, offset);
+
+        } else {
+          assert(false);
+        }
+      default:
+        assert(false);
+    }
+  }
+
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  //   LOADS n' STORES - XMM32
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  static Instruction store32_xmm32_gpr64_plus_gpr64(Register addr1,
+                                                    Register addr2,
+                                                    Register xmm_value) {
+    assert(xmm_value.is_xmm());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x11);
+    instr.set_modrm_and_rex_for_reg_plus_reg_addr(xmm_value.hw_id(), addr1.hw_id(), addr2.hw_id());
+
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  static Instruction load32_xmm32_gpr64_plus_gpr64(Register xmm_dest,
+                                                   Register addr1,
+                                                   Register addr2) {
+    assert(xmm_dest.is_xmm());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x10);
+    instr.set_modrm_and_rex_for_reg_plus_reg_addr(xmm_dest.hw_id(), addr1.hw_id(), addr2.hw_id());
+
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  static Instruction store32_xmm32_gpr64_plus_gpr64_plus_s8(Register addr1,
+                                                            Register addr2,
+                                                            Register xmm_value,
+                                                            s64 offset) {
+    assert(xmm_value.is_xmm());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(offset >= INT8_MIN && offset <= INT8_MAX);
+
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x11);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s8(xmm_value.hw_id(), addr1.hw_id(),
+                                                     addr2.hw_id(), offset, false);
+
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  static Instruction load32_xmm32_gpr64_plus_gpr64_plus_s8(Register xmm_dest,
+                                                           Register addr1,
+                                                           Register addr2,
+                                                           s64 offset) {
+    assert(xmm_dest.is_xmm());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(offset >= INT8_MIN && offset <= INT8_MAX);
+
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x10);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s8(xmm_dest.hw_id(), addr1.hw_id(), addr2.hw_id(),
+                                                     offset, false);
+
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  static Instruction store32_xmm32_gpr64_plus_gpr64_plus_s32(Register addr1,
+                                                             Register addr2,
+                                                             Register xmm_value,
+                                                             s64 offset) {
+    assert(xmm_value.is_xmm());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x11);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s32(xmm_value.hw_id(), addr1.hw_id(),
+                                                      addr2.hw_id(), offset, false);
+
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  static Instruction load32_xmm32_gpr64_plus_gpr64_plus_s32(Register xmm_dest,
+                                                            Register addr1,
+                                                            Register addr2,
+                                                            s64 offset) {
+    assert(xmm_dest.is_xmm());
+    assert(addr1.is_gpr());
+    assert(addr2.is_gpr());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x10);
+    instr.set_modrm_and_rex_for_reg_plus_reg_plus_s32(xmm_dest.hw_id(), addr1.hw_id(),
+                                                      addr2.hw_id(), offset, false);
+
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  static Instruction load_goal_xmm32(Register xmm_dest, Register addr, Register off, s64 offset) {
+    if (offset == 0) {
+      return load32_xmm32_gpr64_plus_gpr64(xmm_dest, addr, off);
+    } else if (offset >= INT8_MIN && offset <= INT8_MAX) {
+      return load32_xmm32_gpr64_plus_gpr64_plus_s8(xmm_dest, addr, off, offset);
+    } else if (offset >= INT32_MIN && offset <= INT32_MAX) {
+      return load32_xmm32_gpr64_plus_gpr64_plus_s32(xmm_dest, addr, off, offset);
+    } else {
+      assert(false);
+    }
+  }
+
+  static Instruction store_goal_xmm32(Register addr, Register xmm_value, Register off, s64 offset) {
+    if (offset == 0) {
+      return store32_xmm32_gpr64_plus_gpr64(addr, off, xmm_value);
+    } else if (offset >= INT8_MIN && offset <= INT8_MAX) {
+      return store32_xmm32_gpr64_plus_gpr64_plus_s8(addr, off, xmm_value, offset);
+    } else if (offset >= INT32_MIN && offset <= INT32_MAX) {
+      return store32_xmm32_gpr64_plus_gpr64_plus_s32(addr, off, xmm_value, offset);
+    } else {
+      assert(false);
+    }
+  }
+
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  //   LOADS n' STORES - XMM128
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  /*!
+   * Store a 128-bit xmm into an address stored in a register, no offset
+   */
+  static Instruction store128_gpr64_xmm128(Register gpr_addr, Register xmm_value) {
+    assert(gpr_addr.is_gpr());
+    assert(xmm_value.is_xmm());
+    Instruction instr(0x66);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x7f);
+    instr.set_modrm_and_rex_for_reg_addr(xmm_value.hw_id(), gpr_addr.hw_id(), false);
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  static Instruction load128_xmm128_gpr64(Register xmm_dest, Register gpr_addr) {
+    assert(gpr_addr.is_gpr());
+    assert(xmm_dest.is_xmm());
+    Instruction instr(0x66);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x6f);
+    instr.set_modrm_and_rex_for_reg_addr(xmm_dest.hw_id(), gpr_addr.hw_id(), false);
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  //   RIP loads and stores
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  static Instruction load64_rip_s32(Register dest, s64 offset) {
+    assert(dest.is_gpr());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x8b);
+    instr.set_modrm_and_rex_for_rip_plus_s32(dest.hw_id(), offset, true);
+    return instr;
+  }
+
+  static Instruction load32s_rip_s32(Register dest, s64 offset) {
+    assert(dest.is_gpr());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x63);
+    instr.set_modrm_and_rex_for_rip_plus_s32(dest.hw_id(), offset, true);
+    return instr;
+  }
+
+  static Instruction load32u_rip_s32(Register dest, s64 offset) {
+    assert(dest.is_gpr());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x8b);
+    instr.set_modrm_and_rex_for_rip_plus_s32(dest.hw_id(), offset, false);
+    return instr;
+  }
+
+  static Instruction load16u_rip_s32(Register dest, s64 offset) {
+    assert(dest.is_gpr());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0xf);
+    instr.set_op2(0xb7);
+    instr.set_modrm_and_rex_for_rip_plus_s32(dest.hw_id(), offset, true);
+    return instr;
+  }
+
+  static Instruction load16s_rip_s32(Register dest, s64 offset) {
+    assert(dest.is_gpr());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0xf);
+    instr.set_op2(0xbf);
+    instr.set_modrm_and_rex_for_rip_plus_s32(dest.hw_id(), offset, true);
+    return instr;
+  }
+
+  static Instruction load8u_rip_s32(Register dest, s64 offset) {
+    assert(dest.is_gpr());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0xf);
+    instr.set_op2(0xb6);
+    instr.set_modrm_and_rex_for_rip_plus_s32(dest.hw_id(), offset, true);
+    return instr;
+  }
+
+  static Instruction load8s_rip_s32(Register dest, s64 offset) {
+    assert(dest.is_gpr());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0xf);
+    instr.set_op2(0xbe);
+    instr.set_modrm_and_rex_for_rip_plus_s32(dest.hw_id(), offset, true);
+    return instr;
+  }
+
+  static Instruction static_load(Register dest, s64 offset, int size, bool sign_extend) {
+    switch (size) {
+      case 1:
+        if (sign_extend) {
+          return load8s_rip_s32(dest, offset);
+        } else {
+          return load8u_rip_s32(dest, offset);
+        }
+        break;
+      case 2:
+        if (sign_extend) {
+          return load16s_rip_s32(dest, offset);
+        } else {
+          return load16u_rip_s32(dest, offset);
+        }
+        break;
+      case 4:
+        if (sign_extend) {
+          return load32s_rip_s32(dest, offset);
+        } else {
+          return load32u_rip_s32(dest, offset);
+        }
+        break;
+      case 8:
+        return load64_rip_s32(dest, offset);
+      default:
+        assert(false);
+    }
+  }
+
+  static Instruction store64_rip_s32(Register src, s64 offset) {
+    assert(src.is_gpr());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x89);
+    instr.set_modrm_and_rex_for_rip_plus_s32(src.hw_id(), offset, true);
+    return instr;
+  }
+
+  static Instruction store32_rip_s32(Register src, s64 offset) {
+    assert(src.is_gpr());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x89);
+    instr.set_modrm_and_rex_for_rip_plus_s32(src.hw_id(), offset, false);
+    return instr;
+  }
+
+  static Instruction store16_rip_s32(Register src, s64 offset) {
+    assert(src.is_gpr());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x66);
+    instr.set_op2(0x89);
+    instr.set_modrm_and_rex_for_rip_plus_s32(src.hw_id(), offset, false);
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  static Instruction store8_rip_s32(Register src, s64 offset) {
+    assert(src.is_gpr());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x88);
+    instr.set_modrm_and_rex_for_rip_plus_s32(src.hw_id(), offset, false);
+    if (src.id() > RBX) {
+      instr.add_rex();
+    }
+    return instr;
+  }
+
+  static Instruction static_store(Register value, s64 offset, int size) {
+    switch (size) {
+      case 1:
+        return store8_rip_s32(value, offset);
+      case 2:
+        return store16_rip_s32(value, offset);
+      case 4:
+        return store32_rip_s32(value, offset);
+      case 8:
+        return store64_rip_s32(value, offset);
+      default:
+        assert(false);
+    }
+  }
+
+  static Instruction static_addr(Register dst, s64 offset) {
+    assert(dst.is_gpr());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+    Instruction instr(0x8d);
+    instr.set_modrm_and_rex_for_rip_plus_s32(dst.hw_id(), offset, true);
+    return instr;
+  }
+
+  static Instruction static_load_xmm32(Register xmm_dest, s64 offset) {
+    assert(xmm_dest.is_xmm());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x10);
+    instr.set_modrm_and_rex_for_rip_plus_s32(xmm_dest.hw_id(), offset, false);
+
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  static Instruction static_store_xmm32(Register xmm_value, s64 offset) {
+    assert(xmm_value.is_xmm());
+    assert(offset >= INT32_MIN && offset <= INT32_MAX);
+
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x11);
+    instr.set_modrm_and_rex_for_rip_plus_s32(xmm_value.hw_id(), offset, false);
+
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  // TODO, special load/stores of 128 bit values.
+
+  // TODO, consider specialized stack loads and stores?
 
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   //   FUNCTION STUFF
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
   /*!
-   * Return instruction
+   * Function return. Pops the 64-bit return address (real) off the stack and jumps to it.
    */
   static Instruction ret() { return Instruction(0xc3); }
 
   /*!
    * Instruction to push gpr (64-bits) onto the stack
    */
-  static Instruction push_gpr64(uint8_t reg) {
-    if (reg >= 8) {
-      auto i = Instruction(0x50 + reg - 8);
+  static Instruction push_gpr64(Register reg) {
+    assert(reg.is_gpr());
+    if (reg.hw_id() >= 8) {
+      auto i = Instruction(0x50 + reg.hw_id() - 8);
       i.set(REX(false, false, false, true));
       return i;
     }
-    return Instruction(0x50 + reg);
+    return Instruction(0x50 + reg.hw_id());
   }
 
   /*!
    * Instruction to pop 64 bit gpr from the stack
    */
-  static Instruction pop_gpr64(uint8_t reg) {
-    if (reg >= 8) {
-      auto i = Instruction(0x58 + reg - 8);
+  static Instruction pop_gpr64(Register reg) {
+    if (reg.hw_id() >= 8) {
+      auto i = Instruction(0x58 + reg.hw_id() - 8);
       i.set(REX(false, false, false, true));
       return i;
     }
-    return Instruction(0x58 + reg);
+    return Instruction(0x58 + reg.hw_id());
   }
 
-  //  /*!
-  //   * Call a function stored in a 64-bit gpr
-  //   */
-  //  static Instruction call_r64(uint8_t reg) {
-  //    Instruction instr(0xff);
-  //    if (reg >= 8) {
-  //      instr.set(REX(false, false, false, true));
-  //      reg -= 8;
-  //    }
-  //    assert(reg < 8);
-  //    ModRM mrm;
-  //    mrm.rm = reg;
-  //    mrm.reg_op = 2;
-  //    mrm.mod = 3;
-  //    instr.set(mrm);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Call a function stored in a 64-bit gpr
-  //   */
-  //  static Instruction jmp_r64(uint8_t reg) {
-  //    Instruction instr(0xff);
-  //    if (reg >= 8) {
-  //      instr.set(REX(false, false, false, true));
-  //      reg -= 8;
-  //    }
-  //    assert(reg < 8);
-  //    ModRM mrm;
-  //    mrm.rm = reg;
-  //    mrm.reg_op = 4;
-  //    mrm.mod = 3;
-  //    instr.set(mrm);
-  //    return instr;
-  //  }
-  //
-  //  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  //  //   INTEGER MATH
-  //  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  //
-  //  /*!
-  //   * Add 64-bit registers.
-  //   */
-  //  static Instruction add_gpr64_gpr64(uint8_t dst, uint8_t src) {
-  //    Instruction instr(0x01);
-  //    instr.set_modrm_and_rex(src, dst, 3, true);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Add a signed 32 bit immediate to a 64 bit register
-  //   * TODO: determine if we can decrease to imm16?
-  //   */
-  //  static Instruction add_gpr64_imm32s(uint8_t dst, int32_t offset) {
-  //    Instruction instr(0x81);
-  //    instr.set_modrm_and_rex(0, dst, 3, true);
-  //    instr.set(Imm(4, offset));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Add a signed 32 bit immediate to a 64 bit register
-  //   * TODO: determine if we can decrease to imm16?
-  //   */
-  //  static Instruction add_gpr64_imm8s(uint8_t dst, int8_t v) {
-  //    Instruction instr(0x83);
-  //    instr.set_modrm_and_rex(0, dst, 3, true);
-  //    instr.set(Imm(1, v));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Subtract 64-bit registers
-  //   */
-  //  static Instruction sub_gpr64_gpr64(uint8_t dst, uint8_t src) {
-  //    Instruction instr(0x29);
-  //    instr.set_modrm_and_rex(src, dst, 3, true);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Multiply gprs (32-bit, signed).
-  //   */
-  //  static Instruction imul_gpr32_gpr32(uint8_t dst, uint8_t src) {
-  //    Instruction instr(0xf);
-  //    instr.set_op2(0xaf);
-  //    instr.set_modrm_and_rex(dst, src, 3, false);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Divide (idiv, 32 bit)
-  //   */
-  //  static Instruction idiv_gpr32(uint8_t reg) {
-  //    Instruction instr(0xf7);
-  //    instr.set_modrm_and_rex(7, reg, 3, false);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Convert doubleword to quadword for division.
-  //   * Blame Intel for this disaster.
-  //   */
-  //  static Instruction cdq() {
-  //    Instruction instr(0x99);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Move from gpr32 to gpr64, with sign extension.
-  //   * Needed for division madness.
-  //   */
-  //  static Instruction movsx_r64_r32(uint8_t dst, uint8_t src) {
-  //    Instruction instr(0x63);
-  //    instr.set_modrm_and_rex(dst, src, 3, true);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Compare gpr64.  This sets the flags for the jumps.
-  //   */
-  //  static Instruction cmp_gpr64_gpr64(uint8_t a, uint8_t b) {
-  //    Instruction instr(0x3b);
-  //    instr.set_modrm_and_rex(a, b, 3, true);
-  //    return instr;
-  //  }
-  //
-  //  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  //  //   BIT STUFF
-  //  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  //
-  //  /*!
-  //   * Or of two gprs
-  //   */
-  //  static Instruction or_gpr64_gpr64(uint8_t dst, uint8_t src) {
-  //    Instruction instr(0x0b);
-  //    instr.set_modrm_and_rex(dst, src, 3, true);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * And of two gprs
-  //   */
-  //  static Instruction and_gpr64_gpr64(uint8_t dst, uint8_t src) {
-  //    Instruction instr(0x23);
-  //    instr.set_modrm_and_rex(dst, src, 3, true);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Xor of two gprs
-  //   */
-  //  static Instruction xor_gpr64_gpr64(uint8_t dst, uint8_t src) {
-  //    Instruction instr(0x33);
-  //    instr.set_modrm_and_rex(dst, src, 3, true);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * This is the way "real" compilers zero registers, so we should do it too.
-  //   */
-  //  static Instruction xor_zero_gpr(uint8_t reg) {
-  //    Instruction instr(0x31);
-  //    instr.set_modrm_and_rex(reg, reg, 3, false);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Bitwise not a gpr
-  //   */
-  //  static Instruction not_gpr64(uint8_t reg) {
-  //    Instruction instr(0xf7);
-  //    instr.set_modrm_and_rex(2, reg, 3, true);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Shift 64-bit gpr left by CL register
-  //   */
-  //  static Instruction shl_gpr64_cl(uint8_t reg) {
-  //    Instruction instr(0xd3);
-  //    instr.set_modrm_and_rex(4, reg, 3, true);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Shift 64-bit gpr right (logical) by CL register
-  //   */
-  //  static Instruction shr_gpr64_cl(uint8_t reg) {
-  //    Instruction instr(0xd3);
-  //    instr.set_modrm_and_rex(5, reg, 3, true);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Shift 64-bit gpr right (arithmetic) by CL register
-  //   */
-  //  static Instruction sar_gpr64_cl(uint8_t reg) {
-  //    Instruction instr(0xd3);
-  //    instr.set_modrm_and_rex(7, reg, 3, true);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Shift 64-ptr left (logical) by the constant shift amount "sa".
-  //   */
-  //  static Instruction shl_gpr64_u8(uint8_t reg, uint8_t sa) {
-  //    Instruction instr(0xc1);
-  //    instr.set_modrm_and_rex(4, reg, 3, true);
-  //    instr.set(Imm(1, sa));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Shift 64-ptr right (logical) by the constant shift amount "sa".
-  //   */
-  //  static Instruction shr_gpr64_u8(uint8_t reg, uint8_t sa) {
-  //    Instruction instr(0xc1);
-  //    instr.set_modrm_and_rex(5, reg, 3, true);
-  //    instr.set(Imm(1, sa));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Shift 64-ptr right (arithmetic) by the constant shift amount "sa".
-  //   */
-  //  static Instruction sar_gpr64_u8(uint8_t reg, uint8_t sa) {
-  //    Instruction instr(0xc1);
-  //    instr.set_modrm_and_rex(7, reg, 3, true);
-  //    instr.set(Imm(1, sa));
-  //    return instr;
-  //  }
-  //
-  //  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  //  //   CONTROL FLOW
-  //  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  //
-  //  /*!
-  //   * Jump, 32-bit constant offset.  The offset is by default 0 and must be patched later.
-  //   */
-  //  static Instruction jmp_32() {
-  //    Instruction instr(0xe9);
-  //    instr.set(Imm(4, 0));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Jump if equal.
-  //   * TODO - can we get away with 16 bits?
-  //   */
-  //  static Instruction je_32() {
-  //    Instruction instr(0x0f);
-  //    instr.set_op2(0x84);
-  //    instr.set(Imm(4, 0));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Jump not equal.
-  //   * TODO - can we get away with 16 bits?
-  //   */
-  //  static Instruction jne_32() {
-  //    Instruction instr(0x0f);
-  //    instr.set_op2(0x85);
-  //    instr.set(Imm(4, 0));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Jump less than or equal.
-  //   * TODO - can we get away with 16 bits?
-  //   */
-  //  static Instruction jle_32() {
-  //    Instruction instr(0x0f);
-  //    instr.set_op2(0x8e);
-  //    instr.set(Imm(4, 0));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Jump greater than or equal.
-  //   * TODO - can we get away with 16 bits?
-  //   */
-  //  static Instruction jge_32() {
-  //    Instruction instr(0x0f);
-  //    instr.set_op2(0x8d);
-  //    instr.set(Imm(4, 0));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Jump less than
-  //   * TODO - can we get away with 16 bits?
-  //   */
-  //  static Instruction jl_32() {
-  //    Instruction instr(0x0f);
-  //    instr.set_op2(0x8c);
-  //    instr.set(Imm(4, 0));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Jump greater than
-  //   * TODO - can we get away with 16 bits?
-  //   */
-  //  static Instruction jg_32() {
-  //    Instruction instr(0x0f);
-  //    instr.set_op2(0x8f);
-  //    instr.set(Imm(4, 0));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Jump below or equal
-  //   * TODO - can we get away with 16 bits?
-  //   */
-  //  static Instruction jbe_32() {
-  //    Instruction instr(0x0f);
-  //    instr.set_op2(0x86);
-  //    instr.set(Imm(4, 0));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Jump above or equal
-  //   * TODO - can we get away with 16 bits?
-  //   */
-  //  static Instruction jae_32() {
-  //    Instruction instr(0x0f);
-  //    instr.set_op2(0x83);
-  //    instr.set(Imm(4, 0));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Jump below
-  //   * TODO - can we get away with 16 bits?
-  //   */
-  //  static Instruction jb_32() {
-  //    Instruction instr(0x0f);
-  //    instr.set_op2(0x82);
-  //    instr.set(Imm(4, 0));
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Jump above
-  //   * TODO - can we get away with 16 bits?
-  //   */
-  //  static Instruction ja_32() {
-  //    Instruction instr(0x0f);
-  //    instr.set_op2(0x87);
-  //    instr.set(Imm(4, 0));
-  //    return instr;
-  //  }
-  //
-  //  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  //  //   FLOAT MATH
-  //  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  //
-  //  /*!
-  //   * Compare two floats and set flag register for jump
-  //   */
-  //  static Instruction cmp_flt_flt(uint8_t a, uint8_t b) {
-  //    Instruction instr(0x0f);
-  //    instr.set_op2(0x2e);
-  //    instr.set_modrm_and_rex(a, b, 3, false);
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Multiply two floats in xmm's
-  //   */
-  //  static Instruction mulss_xmm_xmm(uint8_t dst, uint8_t src) {
-  //    Instruction instr(0xf3);
-  //    instr.set_op2(0x0f);
-  //    instr.set_op3(0x59);
-  //    instr.set_modrm_and_rex(dst, src, 3, false);
-  //    instr.swap_op0_rex();
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Divide two floats in xmm's
-  //   */
-  //  static Instruction divss_xmm_xmm(uint8_t dst, uint8_t src) {
-  //    Instruction instr(0xf3);
-  //    instr.set_op2(0x0f);
-  //    instr.set_op3(0x5e);
-  //    instr.set_modrm_and_rex(dst, src, 3, false);
-  //    instr.swap_op0_rex();
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Subtract two floats in xmm's
-  //   */
-  //  static Instruction subss_xmm_xmm(uint8_t dst, uint8_t src) {
-  //    Instruction instr(0xf3);
-  //    instr.set_op2(0x0f);
-  //    instr.set_op3(0x5c);
-  //    instr.set_modrm_and_rex(dst, src, 3, false);
-  //    instr.swap_op0_rex();
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Add two floats in xmm's
-  //   */
-  //  static Instruction addss_xmm_xmm(uint8_t dst, uint8_t src) {
-  //    Instruction instr(0xf3);
-  //    instr.set_op2(0x0f);
-  //    instr.set_op3(0x58);
-  //    instr.set_modrm_and_rex(dst, src, 3, false);
-  //    instr.swap_op0_rex();
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Convert GPR int32 to XMM float (single precision)
-  //   */
-  //  static Instruction int32_to_float(uint8_t dst, uint8_t src) {
-  //    Instruction instr(0xf3);
-  //    instr.set_op2(0x0f);
-  //    instr.set_op3(0x2a);
-  //    instr.set_modrm_and_rex(dst, src, 3, false);
-  //    instr.swap_op0_rex();
-  //    return instr;
-  //  }
-  //
-  //  /*!
-  //   * Convert XMM float to GPR int32(single precision) (truncate)
-  //   */
-  //  static Instruction float_to_int64(uint8_t dst, uint8_t src) {
-  //    Instruction instr(0xf3);
-  //    instr.set_op2(0x0f);
-  //    instr.set_op3(0x2c);
-  //    instr.set_modrm_and_rex(dst, src, 3, true);
-  //    instr.swap_op0_rex();
-  //    return instr;
-  //  }
-  //
-  //  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  //  //   UTILITIES
-  //  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  //
-  //  /*!
-  //   * A "null" instruction.  This instruction does not generate any bytes
-  //   * but can be referred to by a label.  Useful to insert in place of a real instruction
-  //   * if the real instruction has been optimized out.
-  //   */
-  //  static Instruction null() {
-  //    Instruction i(0);
-  //    i.is_null = true;
-  //    return i;
-  //  }
-  //
-  //  /*!
-  //   * A "function start" instruction.  This emits no opcodes, but is used
-  //   * to determine where to insert the function type tag and how to align a function.
-  //   */
-  //  static Instruction function_start() {
-  //    Instruction i(0);
-  //    i.is_null = true;
-  //    i.is_function_start = true;
-  //    return i;
-  //  }
-};
-}  // namespace goal
+  /*!
+   * Call a function stored in a 64-bit gpr
+   */
+  static Instruction call_r64(uint8_t reg) {
+    Instruction instr(0xff);
+    if (reg >= 8) {
+      instr.set(REX(false, false, false, true));
+      reg -= 8;
+    }
+    assert(reg < 8);
+    ModRM mrm;
+    mrm.rm = reg;
+    mrm.reg_op = 2;
+    mrm.mod = 3;
+    instr.set(mrm);
+    return instr;
+  }
 
-#endif  // JAK1_IGEN_H
+  /*!
+   * Call a function stored in a 64-bit gpr
+   */
+  static Instruction jmp_r64(uint8_t reg) {
+    Instruction instr(0xff);
+    if (reg >= 8) {
+      instr.set(REX(false, false, false, true));
+      reg -= 8;
+    }
+    assert(reg < 8);
+    ModRM mrm;
+    mrm.rm = reg;
+    mrm.reg_op = 4;
+    mrm.mod = 3;
+    instr.set(mrm);
+    return instr;
+  }
+
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  //   INTEGER MATH
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  static Instruction sub_gpr64_imm8s(Register reg, int64_t imm) {
+    assert(reg.is_gpr());
+    assert(imm >= INT8_MIN && imm <= INT8_MAX);
+    // SUB r/m64, imm8 : REX.W + 83 /5 ib
+    Instruction instr(0x83);
+    instr.set_modrm_and_rex(5, reg.hw_id(), 3, true);
+    instr.set(Imm(1, imm));
+    return instr;
+  }
+
+  static Instruction sub_gpr64_imm32s(Register reg, int64_t imm) {
+    assert(reg.is_gpr());
+    assert(imm >= INT32_MIN && imm <= INT32_MAX);
+    Instruction instr(0x81);
+    instr.set_modrm_and_rex(5, reg.hw_id(), 3, true);
+    instr.set(Imm(4, imm));
+    return instr;
+  }
+
+  static Instruction add_gpr64_imm8s(Register reg, int64_t v) {
+    assert(v >= INT8_MIN && v <= INT8_MAX);
+    Instruction instr(0x83);
+    instr.set_modrm_and_rex(0, reg.hw_id(), 3, true);
+    instr.set(Imm(1, v));
+    return instr;
+  }
+
+  static Instruction add_gpr64_imm32s(Register reg, int64_t v) {
+    assert(v >= INT32_MIN && v <= INT32_MAX);
+    Instruction instr(0x81);
+    instr.set_modrm_and_rex(0, reg.hw_id(), 3, true);
+    instr.set(Imm(4, v));
+    return instr;
+  }
+
+  static Instruction add_gpr64_imm(Register reg, int64_t imm) {
+    if (imm >= INT8_MIN && imm <= INT8_MAX) {
+      return add_gpr64_imm8s(reg, imm);
+    } else if (imm >= INT32_MIN && imm <= INT32_MAX) {
+      return add_gpr64_imm32s(reg, imm);
+    } else {
+      assert(false);
+    }
+  }
+
+  static Instruction sub_gpr64_imm(Register reg, int64_t imm) {
+    if (imm >= INT8_MIN && imm <= INT8_MAX) {
+      return sub_gpr64_imm8s(reg, imm);
+    } else if (imm >= INT32_MIN && imm <= INT32_MAX) {
+      return sub_gpr64_imm32s(reg, imm);
+    } else {
+      assert(false);
+    }
+  }
+
+  static Instruction add_gpr64_gpr64(Register dst, Register src) {
+    Instruction instr(0x01);
+    assert(dst.is_gpr());
+    assert(src.is_gpr());
+    instr.set_modrm_and_rex(src.hw_id(), dst.hw_id(), 3, true);
+    return instr;
+  }
+
+  static Instruction sub_gpr64_gpr64(Register dst, Register src) {
+    Instruction instr(0x29);
+    assert(dst.is_gpr());
+    assert(src.is_gpr());
+    instr.set_modrm_and_rex(src.hw_id(), dst.hw_id(), 3, true);
+    return instr;
+  }
+
+  /*!
+   * Multiply gprs (32-bit, signed).
+   * (Note - probably worth doing imul on gpr64's to implement the EE's unsigned multiply)
+   */
+  static Instruction imul_gpr32_gpr32(Register dst, Register src) {
+    Instruction instr(0xf);
+    instr.set_op2(0xaf);
+    assert(dst.is_gpr());
+    assert(src.is_gpr());
+    instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, false);
+    return instr;
+  }
+
+  /*!
+   * Divide (idiv, 32 bit)
+   * todo UNTESTED
+   */
+  static Instruction idiv_gpr32(Register reg) {
+    Instruction instr(0xf7);
+    assert(reg.is_gpr());
+    instr.set_modrm_and_rex(7, reg.hw_id(), 3, false);
+    return instr;
+  }
+
+  /*!
+   * Convert doubleword to quadword for division.
+   * todo UNTESTED
+   */
+  static Instruction cdq() {
+    Instruction instr(0x99);
+    return instr;
+  }
+
+  /*!
+   * Move from gpr32 to gpr64, with sign extension.
+   * Needed for multiplication/divsion madness.
+   */
+  static Instruction movsx_r64_r32(Register dst, Register src) {
+    Instruction instr(0x63);
+    assert(dst.is_gpr());
+    assert(src.is_gpr());
+    instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, true);
+    return instr;
+  }
+
+  /*!
+   * Compare gpr64.  This sets the flags for the jumps.
+   * todo UNTESTED
+   */
+  static Instruction cmp_gpr64_gpr64(Register a, Register b) {
+    Instruction instr(0x3b);
+    assert(a.is_gpr());
+    assert(b.is_gpr());
+    instr.set_modrm_and_rex(a.hw_id(), b.hw_id(), 3, true);
+    return instr;
+  }
+
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  //   BIT STUFF
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  /*!
+   * Or of two gprs
+   */
+  static Instruction or_gpr64_gpr64(Register dst, Register src) {
+    Instruction instr(0x0b);
+    assert(dst.is_gpr());
+    assert(src.is_gpr());
+    instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, true);
+    return instr;
+  }
+
+  /*!
+   * And of two gprs
+   */
+  static Instruction and_gpr64_gpr64(Register dst, Register src) {
+    Instruction instr(0x23);
+    assert(dst.is_gpr());
+    assert(src.is_gpr());
+    instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, true);
+    return instr;
+  }
+
+  /*!
+   * Xor of two gprs
+   */
+  static Instruction xor_gpr64_gpr64(Register dst, Register src) {
+    Instruction instr(0x33);
+    assert(dst.is_gpr());
+    assert(src.is_gpr());
+    instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, true);
+    return instr;
+  }
+
+  /*!
+   * Bitwise not a gpr
+   */
+  static Instruction not_gpr64(Register reg) {
+    Instruction instr(0xf7);
+    assert(reg.is_gpr());
+    instr.set_modrm_and_rex(2, reg.hw_id(), 3, true);
+    return instr;
+  }
+
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  //   SHIFTS
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  /*!
+   * Shift 64-bit gpr left by CL register
+   */
+  static Instruction shl_gpr64_cl(uint8_t reg) {
+    Instruction instr(0xd3);
+    instr.set_modrm_and_rex(4, reg, 3, true);
+    return instr;
+  }
+
+  /*!
+   * Shift 64-bit gpr right (logical) by CL register
+   */
+  static Instruction shr_gpr64_cl(uint8_t reg) {
+    Instruction instr(0xd3);
+    instr.set_modrm_and_rex(5, reg, 3, true);
+    return instr;
+  }
+
+  /*!
+   * Shift 64-bit gpr right (arithmetic) by CL register
+   */
+  static Instruction sar_gpr64_cl(uint8_t reg) {
+    Instruction instr(0xd3);
+    instr.set_modrm_and_rex(7, reg, 3, true);
+    return instr;
+  }
+
+  /*!
+   * Shift 64-ptr left (logical) by the constant shift amount "sa".
+   */
+  static Instruction shl_gpr64_u8(uint8_t reg, uint8_t sa) {
+    Instruction instr(0xc1);
+    instr.set_modrm_and_rex(4, reg, 3, true);
+    instr.set(Imm(1, sa));
+    return instr;
+  }
+
+  /*!
+   * Shift 64-ptr right (logical) by the constant shift amount "sa".
+   */
+  static Instruction shr_gpr64_u8(uint8_t reg, uint8_t sa) {
+    Instruction instr(0xc1);
+    instr.set_modrm_and_rex(5, reg, 3, true);
+    instr.set(Imm(1, sa));
+    return instr;
+  }
+
+  /*!
+   * Shift 64-ptr right (arithmetic) by the constant shift amount "sa".
+   */
+  static Instruction sar_gpr64_u8(uint8_t reg, uint8_t sa) {
+    Instruction instr(0xc1);
+    instr.set_modrm_and_rex(7, reg, 3, true);
+    instr.set(Imm(1, sa));
+    return instr;
+  }
+
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  //   CONTROL FLOW
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  /*!
+   * Jump, 32-bit constant offset.  The offset is by default 0 and must be patched later.
+   */
+  static Instruction jmp_32() {
+    Instruction instr(0xe9);
+    instr.set(Imm(4, 0));
+    return instr;
+  }
+
+  /*!
+   * Jump if equal.
+   */
+  static Instruction je_32() {
+    Instruction instr(0x0f);
+    instr.set_op2(0x84);
+    instr.set(Imm(4, 0));
+    return instr;
+  }
+
+  /*!
+   * Jump not equal.
+   */
+  static Instruction jne_32() {
+    Instruction instr(0x0f);
+    instr.set_op2(0x85);
+    instr.set(Imm(4, 0));
+    return instr;
+  }
+
+  /*!
+   * Jump less than or equal.
+   */
+  static Instruction jle_32() {
+    Instruction instr(0x0f);
+    instr.set_op2(0x8e);
+    instr.set(Imm(4, 0));
+    return instr;
+  }
+
+  /*!
+   * Jump greater than or equal.
+   */
+  static Instruction jge_32() {
+    Instruction instr(0x0f);
+    instr.set_op2(0x8d);
+    instr.set(Imm(4, 0));
+    return instr;
+  }
+
+  /*!
+   * Jump less than
+   */
+  static Instruction jl_32() {
+    Instruction instr(0x0f);
+    instr.set_op2(0x8c);
+    instr.set(Imm(4, 0));
+    return instr;
+  }
+
+  /*!
+   * Jump greater than
+   */
+  static Instruction jg_32() {
+    Instruction instr(0x0f);
+    instr.set_op2(0x8f);
+    instr.set(Imm(4, 0));
+    return instr;
+  }
+
+  /*!
+   * Jump below or equal
+   */
+  static Instruction jbe_32() {
+    Instruction instr(0x0f);
+    instr.set_op2(0x86);
+    instr.set(Imm(4, 0));
+    return instr;
+  }
+
+  /*!
+   * Jump above or equal
+   */
+  static Instruction jae_32() {
+    Instruction instr(0x0f);
+    instr.set_op2(0x83);
+    instr.set(Imm(4, 0));
+    return instr;
+  }
+
+  /*!
+   * Jump below
+   */
+  static Instruction jb_32() {
+    Instruction instr(0x0f);
+    instr.set_op2(0x82);
+    instr.set(Imm(4, 0));
+    return instr;
+  }
+
+  /*!
+   * Jump above
+   */
+  static Instruction ja_32() {
+    Instruction instr(0x0f);
+    instr.set_op2(0x87);
+    instr.set(Imm(4, 0));
+    return instr;
+  }
+
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  //   FLOAT MATH
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  /*!
+   * Compare two floats and set flag register for jump (ucomiss)
+   */
+  static Instruction cmp_flt_flt(Register a, Register b) {
+    assert(a.is_xmm());
+    assert(b.is_xmm());
+    Instruction instr(0x0f);
+    instr.set_op2(0x2e);
+    instr.set_modrm_and_rex(a.hw_id(), b.hw_id(), 3, false);
+    return instr;
+  }
+
+  /*!
+   * Multiply two floats in xmm's
+   */
+  static Instruction mulss_xmm_xmm(Register dst, Register src) {
+    assert(dst.is_xmm());
+    assert(src.is_xmm());
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x59);
+    instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, false);
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  /*!
+   * Divide two floats in xmm's
+   */
+  static Instruction divss_xmm_xmm(Register dst, Register src) {
+    assert(dst.is_xmm());
+    assert(src.is_xmm());
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x5e);
+    instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, false);
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  /*!
+   * Subtract two floats in xmm's
+   */
+  static Instruction subss_xmm_xmm(Register dst, Register src) {
+    assert(dst.is_xmm());
+    assert(src.is_xmm());
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x5c);
+    instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, false);
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  /*!
+   * Add two floats in xmm's
+   */
+  static Instruction addss_xmm_xmm(Register dst, Register src) {
+    assert(dst.is_xmm());
+    assert(src.is_xmm());
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x58);
+    instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, false);
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  /*!
+   * Convert GPR int32 to XMM float (single precision)
+   */
+  static Instruction int32_to_float(Register dst, Register src) {
+    assert(dst.is_xmm());
+    assert(src.is_gpr());
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x2a);
+    instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, false);
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  /*!
+   * Convert XMM float to GPR int32(single precision) (truncate)
+   */
+  static Instruction float_to_int32(Register dst, Register src) {
+    assert(dst.is_gpr());
+    assert(src.is_xmm());
+    Instruction instr(0xf3);
+    instr.set_op2(0x0f);
+    instr.set_op3(0x2c);
+    instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, false);
+    instr.swap_op0_rex();
+    return instr;
+  }
+
+  // eventually...
+  // sqrt
+  // rsqrt
+  // abs
+
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  //   UTILITIES
+  //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  /*!
+   * A "null" instruction.  This instruction does not generate any bytes
+   * but can be referred to by a label.  Useful to insert in place of a real instruction
+   * if the real instruction has been optimized out.
+   */
+  static Instruction null() {
+    Instruction i(0);
+    i.is_null = true;
+    return i;
+  }
+};
+}  // namespace emitter
+
+#endif  // JAK_IGEN_H
diff --git a/goalc/emitter/Instruction.h b/goalc/emitter/Instruction.h
index 1049ed0790..aab76e1a42 100644
--- a/goalc/emitter/Instruction.h
+++ b/goalc/emitter/Instruction.h
@@ -1,15 +1,10 @@
-/*!
- * @file Instruction.h
- * x86-64 instruction encoding
- */
-#ifndef JAK1_INSTRUCTION_H
-#define JAK1_INSTRUCTION_H
+#ifndef JAK_INSTRUCTION_H
+#define JAK_INSTRUCTION_H
 
 #include <cassert>
 #include "common/common_types.h"
 
-namespace goal {
-
+namespace emitter {
 /*!
  * The ModRM byte
  */
@@ -18,9 +13,7 @@ struct ModRM {
   uint8_t reg_op;
   uint8_t rm;
 
-  uint8_t operator()() const {
-    return (mod << 6) | (reg_op << 3) | (rm << 0);
-  }
+  uint8_t operator()() const { return (mod << 6) | (reg_op << 3) | (rm << 0); }
 };
 
 /*!
@@ -29,9 +22,7 @@ struct ModRM {
 struct SIB {
   uint8_t scale, index, base;
 
-  uint8_t operator()() const {
-    return (scale << 6) | (index << 3) | (base << 0);
-  }
+  uint8_t operator()() const { return (scale << 6) | (index << 3) | (base << 0); }
 };
 
 /*!
@@ -39,35 +30,33 @@ struct SIB {
  */
 struct Imm {
   Imm() = default;
-  Imm(uint8_t sz, uint64_t v) : size(sz), value(v) { }
+  Imm(uint8_t sz, uint64_t v) : size(sz), value(v) {}
   uint8_t size;
   union {
     uint64_t value;
     uint8_t v_arr[8];
   };
-
 };
 
 /*!
  * The REX prefix byte
  */
 struct REX {
-  explicit REX(bool w = false, bool r = false, bool x = false, bool b = false) : W(w), R(r), X(x), B(b) { }
+  explicit REX(bool w = false, bool r = false, bool x = false, bool b = false)
+      : W(w), R(r), X(x), B(b) {}
   // W - 64-bit operands
   // R - reg extension
   // X - SIB i extnsion
   // B - other extension
   bool W, R, X, B;
-  uint8_t operator()() const {
-    return (1 << 6) | (W << 3) | (R << 2) | (X << 1) | (B << 0);
-  }
+  uint8_t operator()() const { return (1 << 6) | (W << 3) | (R << 2) | (X << 1) | (B << 0); }
 };
 
 /*!
  * A high-level description of an x86-64 opcode.  It can emit itself.
  */
 struct Instruction {
-  Instruction(uint8_t opcode) : op(opcode) { }
+  Instruction(uint8_t opcode) : op(opcode) {}
   uint8_t op;
 
   bool op2_set = false;
@@ -110,7 +99,8 @@ struct Instruction {
    * Move opcode byte 0 to before the rex prefix.
    */
   void swap_op0_rex() {
-    if(!set_rex) return;
+    if (!set_rex)
+      return;
     auto temp = op;
     op = m_rex;
     m_rex = temp;
@@ -157,12 +147,12 @@ struct Instruction {
   void set_modrm_and_rex(uint8_t reg, uint8_t rm, uint8_t mod, bool rex_w = false) {
     bool rex_b = false, rex_r = false;
 
-    if(rm >= 8) {
+    if (rm >= 8) {
       rm -= 8;
       rex_b = true;
     }
 
-    if(reg >= 8) {
+    if (reg >= 8) {
       reg -= 8;
       rex_r = true;
     }
@@ -174,36 +164,218 @@ struct Instruction {
 
     set(modrm);
 
-    if(rex_b || rex_w || rex_r) {
+    if (rex_b || rex_w || rex_r) {
       set(REX(rex_w, rex_r, false, rex_b));
     }
   }
 
+  void set_modrm_and_rex_for_reg_plus_reg_plus_s8(uint8_t reg,
+                                                  uint8_t addr1,
+                                                  uint8_t addr2,
+                                                  s8 offset,
+                                                  bool rex_w) {
+    bool rex_b = false, rex_r = false, rex_x = false;
+    bool addr1_ext = false;
+    bool addr2_ext = false;
+
+    if (addr1 >= 8) {
+      addr1 -= 8;
+      addr1_ext = true;
+    }
+
+    if (addr2 >= 8) {
+      addr2 -= 8;
+      addr2_ext = true;
+    }
+
+    if (reg >= 8) {
+      reg -= 8;
+      rex_r = true;
+    }
+
+    ModRM modrm;
+    modrm.mod = 1;  // no disp
+    modrm.rm = 4;   // sib!
+    modrm.reg_op = reg;
+
+    SIB sib;
+    sib.scale = 0;
+
+    Imm imm2(1, offset);
+
+    // default  addr1 in index
+    if (addr1 == 4) {
+      sib.index = addr2;
+      sib.base = addr1;
+      rex_x = addr2_ext;
+      rex_b = addr1_ext;
+    } else {
+      // addr1 in index
+      sib.index = addr1;
+      sib.base = addr2;
+      rex_x = addr1_ext;
+      rex_b = addr2_ext;
+    }
+    assert(sib.index != 4);
+
+    if (rex_b || rex_w || rex_r || rex_x) {
+      set(REX(rex_w, rex_r, rex_x, rex_b));
+    }
+
+    set(modrm);
+    set(sib);
+    set_disp(imm2);
+  }
+
+  void set_modrm_and_rex_for_reg_plus_reg_plus_s32(uint8_t reg,
+                                                   uint8_t addr1,
+                                                   uint8_t addr2,
+                                                   s32 offset,
+                                                   bool rex_w) {
+    bool rex_b = false, rex_r = false, rex_x = false;
+    bool addr1_ext = false;
+    bool addr2_ext = false;
+
+    if (addr1 >= 8) {
+      addr1 -= 8;
+      addr1_ext = true;
+    }
+
+    if (addr2 >= 8) {
+      addr2 -= 8;
+      addr2_ext = true;
+    }
+
+    if (reg >= 8) {
+      reg -= 8;
+      rex_r = true;
+    }
+
+    ModRM modrm;
+    modrm.mod = 2;  // no disp
+    modrm.rm = 4;   // sib!
+    modrm.reg_op = reg;
+
+    SIB sib;
+    sib.scale = 0;
+
+    Imm imm2(4, offset);
+
+    // default  addr1 in index
+    if (addr1 == 4) {
+      sib.index = addr2;
+      sib.base = addr1;
+      rex_x = addr2_ext;
+      rex_b = addr1_ext;
+    } else {
+      // addr1 in index
+      sib.index = addr1;
+      sib.base = addr2;
+      rex_x = addr1_ext;
+      rex_b = addr2_ext;
+    }
+    assert(sib.index != 4);
+
+    if (rex_b || rex_w || rex_r || rex_x) {
+      set(REX(rex_w, rex_r, rex_x, rex_b));
+    }
+
+    set(modrm);
+    set(sib);
+    set_disp(imm2);
+  }
+
+  void set_modrm_and_rex_for_reg_plus_reg_addr(uint8_t reg,
+                                               uint8_t addr1,
+                                               uint8_t addr2,
+                                               bool rex_w = false,
+                                               bool rex_always = false) {
+    bool rex_b = false, rex_r = false, rex_x = false;
+    bool addr1_ext = false;
+    bool addr2_ext = false;
+
+    if (addr1 >= 8) {
+      addr1 -= 8;
+      addr1_ext = true;
+    }
+
+    if (addr2 >= 8) {
+      addr2 -= 8;
+      addr2_ext = true;
+    }
+
+    if (reg >= 8) {
+      reg -= 8;
+      rex_r = true;
+    }
+
+    ModRM modrm;
+    modrm.mod = 0;  // no disp
+    modrm.rm = 4;   // sib!
+    modrm.reg_op = reg;
+
+    SIB sib;
+    sib.scale = 0;
+
+    if (addr1 == 5 && addr2 == 5) {
+      sib.index = addr1;
+      sib.base = addr2;
+      rex_x = addr1_ext;
+      rex_b = addr2_ext;
+      modrm.mod = 1;
+      set_disp(Imm(1, 0));
+
+    } else {
+      // default  addr1 in index
+      bool flipped = (addr1 == 4) || (addr2 == 5);
+
+      if (flipped) {
+        sib.index = addr2;
+        sib.base = addr1;
+        rex_x = addr2_ext;
+        rex_b = addr1_ext;
+      } else {
+        // addr1 in index
+        sib.index = addr1;
+        sib.base = addr2;
+        rex_x = addr1_ext;
+        rex_b = addr2_ext;
+      }
+      assert(sib.base != 5);
+      assert(sib.index != 4);
+    }
+
+    if (rex_b || rex_w || rex_r || rex_x || rex_always) {
+      set(REX(rex_w, rex_r, rex_x, rex_b));
+    }
+
+    set(modrm);
+    set(sib);
+  }
+
   /*!
    * Set modrm and rex as needed for two regs for an addressing mode.
    * Will set SIB if R12 or RSP indexing is used.
    */
-  void set_modrm_and_rex_for_addr(uint8_t reg, uint8_t rm, uint8_t mod, bool rex_w = false) {
+  void set_modrm_and_rex_for_reg_addr(uint8_t reg, uint8_t rm, bool rex_w = false) {
     bool rex_b = false, rex_r = false;
 
-    if(rm >= 8) {
+    if (rm >= 8) {
       rm -= 8;
       rex_b = true;
     }
 
-    if(reg >= 8) {
+    if (reg >= 8) {
       reg -= 8;
       rex_r = true;
     }
 
     ModRM modrm;
-    modrm.mod = mod;
+    modrm.mod = 0;
     modrm.reg_op = reg;
     modrm.rm = rm;
 
-    set(modrm);
-
-    if(rm == 4) {
+    if (rm == 4) {
       SIB sib;
       sib.scale = 0;
       sib.base = 4;
@@ -212,13 +384,40 @@ struct Instruction {
       set(sib);
     }
 
-    if(rex_b || rex_w || rex_r) {
+    if (rm == 5) {
+      modrm.mod = 1;  // 1 byte imm
+      set_disp(Imm(1, 0));
+    }
+
+    set(modrm);
+    if (rex_b || rex_w || rex_r) {
       set(REX(rex_w, rex_r, false, rex_b));
     }
   }
 
+  void set_modrm_and_rex_for_rip_plus_s32(uint8_t reg, s32 offset, bool rex_w = false) {
+    bool rex_r = false;
+
+    if (reg >= 8) {
+      reg -= 8;
+      rex_r = true;
+    }
+
+    ModRM modrm;
+    modrm.mod = 0;
+    modrm.reg_op = reg;
+    modrm.rm = 5;  // use the RIP addressing mode
+    set(modrm);
+
+    if (rex_r || rex_w) {
+      set(REX(rex_w, rex_r, false, false));
+    }
+
+    set_disp(Imm(4, offset));
+  }
+
   void add_rex() {
-    if(!set_rex) {
+    if (!set_rex) {
       set(REX());
     }
   }
@@ -230,7 +429,7 @@ struct Instruction {
     ModRM modrm;
 
     bool rex_r = false;
-    if(reg >= 8) {
+    if (reg >= 8) {
       reg -= 8;
       rex_r = true;
     }
@@ -238,13 +437,13 @@ struct Instruction {
 
     modrm.mod = mod;
 
-    modrm.rm = 4; // use sib
+    modrm.rm = 4;  // use sib
 
     SIB sib;
     sib.scale = 0;
     sib.index = 4;
     bool rex_b = false;
-    if(rm >= 8) {
+    if (rm >= 8) {
       rex_b = true;
       rm -= 8;
     }
@@ -254,25 +453,30 @@ struct Instruction {
     set(modrm);
     set(sib);
 
-    if(rex_r || rex_w || rex_b) {
+    if (rex_r || rex_w || rex_b) {
       set(REX(rex_w, rex_r, false, rex_b));
     }
   }
 
-
   /*!
    * Get the position of the disp immediate relative to the start of the instruction
    */
   int offset_of_disp() const {
-    if(is_null) return 0;
+    if (is_null)
+      return 0;
     assert(set_disp_imm);
     int offset = 0;
-    if(set_rex) offset++;
-    offset++; // opcode
-    if(op2_set) offset++;
-    if(op3_set) offset++;
-    if(set_modrm) offset++;
-    if(set_sib) offset++;
+    if (set_rex)
+      offset++;
+    offset++;  // opcode
+    if (op2_set)
+      offset++;
+    if (op3_set)
+      offset++;
+    if (set_modrm)
+      offset++;
+    if (set_sib)
+      offset++;
     return offset;
   }
 
@@ -280,16 +484,23 @@ struct Instruction {
    * Get the position of the imm immediate relative to the start of the instruction
    */
   int offset_of_imm() const {
-    if(is_null) return 0;
+    if (is_null)
+      return 0;
     assert(set_imm);
     int offset = 0;
-    if(set_rex) offset++;
-    offset++; // opcode
-    if(op2_set) offset++;
-    if(op3_set) offset++;
-    if(set_modrm) offset++;
-    if(set_sib) offset++;
-    if(set_disp_imm) offset += disp.size;
+    if (set_rex)
+      offset++;
+    offset++;  // opcode
+    if (op2_set)
+      offset++;
+    if (op3_set)
+      offset++;
+    if (set_modrm)
+      offset++;
+    if (set_sib)
+      offset++;
+    if (set_disp_imm)
+      offset += disp.size;
     return offset;
   }
 
@@ -297,44 +508,85 @@ struct Instruction {
    * Emit into a buffer and return how many bytes written (can be zero)
    */
   uint8_t emit(uint8_t* buffer) const {
-    if(is_null) return 0;
+    if (is_null)
+      return 0;
     uint8_t count = 0;
-    if(set_rex) {
+    if (set_rex) {
       buffer[count++] = m_rex;
     }
 
     buffer[count++] = op;
 
-    if(op2_set) {
+    if (op2_set) {
       buffer[count++] = op2;
     }
 
-    if(op3_set) {
+    if (op3_set) {
       buffer[count++] = op3;
     }
 
-    if(set_modrm) {
+    if (set_modrm) {
       buffer[count++] = m_modrm;
     }
 
-    if(set_sib) {
+    if (set_sib) {
       buffer[count++] = m_sib;
     }
 
-    if(set_disp_imm) {
-      for(int i = 0; i < disp.size; i++) {
+    if (set_disp_imm) {
+      for (int i = 0; i < disp.size; i++) {
         buffer[count++] = disp.v_arr[i];
       }
     }
 
-    if(set_imm) {
-      for(int i = 0; i < imm.size; i++) {
+    if (set_imm) {
+      for (int i = 0; i < imm.size; i++) {
         buffer[count++] = imm.v_arr[i];
       }
     }
     return count;
   }
-};
-}
 
-#endif  // JAK1_INSTRUCTION_H
+  uint8_t length() const {
+    if (is_null)
+      return 0;
+    uint8_t count = 0;
+    if (set_rex) {
+      count++;
+    }
+
+    count++;
+
+    if (op2_set) {
+      count++;
+    }
+
+    if (op3_set) {
+      count++;
+    }
+
+    if (set_modrm) {
+      count++;
+    }
+
+    if (set_sib) {
+      count++;
+    }
+
+    if (set_disp_imm) {
+      for (int i = 0; i < disp.size; i++) {
+        count++;
+      }
+    }
+
+    if (set_imm) {
+      for (int i = 0; i < imm.size; i++) {
+        count++;
+      }
+    }
+    return count;
+  }
+};
+}  // namespace emitter
+
+#endif  // JAK_INSTRUCTION_H
diff --git a/goalc/emitter/Register.cpp b/goalc/emitter/Register.cpp
new file mode 100644
index 0000000000..30cac4b18f
--- /dev/null
+++ b/goalc/emitter/Register.cpp
@@ -0,0 +1,33 @@
+#include "Register.h"
+
+namespace emitter {
+RegisterInfo RegisterInfo::make_register_info() {
+  RegisterInfo info;
+
+  info.m_info[RAX] = {-1, false, false, "rax"};
+  info.m_info[RCX] = {3, false, false, "rcx"};
+  info.m_info[RDX] = {2, false, false, "rdx"};
+  info.m_info[RBX] = {-1, true, false, "rbx"};
+  info.m_info[RSP] = {-1, false, true, "rsp"};
+  info.m_info[RBP] = {-1, true, false, "rbp"};
+  info.m_info[RSI] = {1, false, false, "rsi"};
+  info.m_info[RDI] = {0, false, false, "rdi"};
+
+  info.m_info[R8] = {4, false, false, "r8"};
+  info.m_info[R9] = {5, false, false, "r9"};
+  info.m_info[R10] = {6, true, false, "r10"};
+  info.m_info[R11] = {7, true, false, "r11"};
+  info.m_info[R12] = {-1, true, false, "r12"};
+  info.m_info[R13] = {-1, false, true, "r13"};  // pp?
+  info.m_info[R14] = {-1, false, true, "r14"};  // st?
+  info.m_info[R15] = {-1, false, true, "r15"};  // offset.
+
+  info.m_arg_regs = std::array<Register, N_ARGS>({RDI, RSI, RDX, RCX, R8, R9, R10, R11});
+  info.m_saved_gprs = std::array<Register, N_SAVED_GPRS>({RBX, RBP, R10, R11, R12});
+  info.m_saved_xmms =
+      std::array<Register, N_SAVED_XMMS>({XMM8, XMM9, XMM10, XMM11, XMM12, XMM13, XMM14, XMM15});
+
+  return info;
+}
+
+}  // namespace emitter
\ No newline at end of file
diff --git a/goalc/emitter/Register.h b/goalc/emitter/Register.h
new file mode 100644
index 0000000000..1e46393bb3
--- /dev/null
+++ b/goalc/emitter/Register.h
@@ -0,0 +1,134 @@
+/*!
+ * @file Register.h
+ * Representation of an x86-64 Register.
+ */
+
+#ifndef JAK_REGISTER_H
+#define JAK_REGISTER_H
+
+#include <cassert>
+#include <functional>
+#include <array>
+#include "common/common_types.h"
+
+namespace emitter {
+
+// registers by name
+enum X86_REG : u8 {
+  RAX,  // return, temp
+  RCX,  // arg 3, temp
+  RDX,  // arg 2, temp
+  RBX,  // saved
+
+  RSP,  // stack pointer (special)
+  RBP,  // saved
+  RSI,  // arg 1, temp
+  RDI,  // arg 0, temp
+
+  R8,   // arg 4, temp
+  R9,   // arg 5, temp
+  R10,  // arg 6, saved (arg in GOAL only)
+  R11,  // arg 7, saved (arg in GOAL only)
+  R12,  // saved
+  R13,  // pp (special!)
+  R14,  // st (special!)
+  R15,  // offset (special!)
+  XMM0,
+  XMM1,
+  XMM2,
+  XMM3,
+  XMM4,
+  XMM5,
+  XMM6,
+  XMM7,
+  XMM8,
+  XMM9,
+  XMM10,
+  XMM11,
+  XMM12,
+  XMM13,
+  XMM14,
+  XMM15
+};
+
+class Register {
+ public:
+  Register() = default;
+
+  // intentionally not explicit so we can use X86_REGs in place of Registers
+  Register(int id) : m_id(id) {}
+
+  bool is_xmm() const { return m_id >= XMM0 && m_id <= XMM15; }
+
+  bool is_gpr() const { return m_id >= RAX && m_id <= R15; }
+
+  int hw_id() const {
+    if (is_xmm()) {
+      return m_id - XMM0;
+    } else if (is_gpr()) {
+      return m_id - RAX;
+    } else {
+      assert(false);
+    }
+    return 0xff;
+  }
+
+  int id() const { return m_id; }
+
+  struct hash {
+    auto operator()(const Register& x) const { return std::hash<u8>()(x.m_id); }
+  };
+
+  bool operator==(const Register& x) const { return m_id == x.m_id; }
+
+  bool operator!=(const Register& x) const { return m_id != x.m_id; }
+
+ private:
+  u8 m_id = 0xff;
+};
+
+class RegisterInfo {
+ public:
+  static constexpr int N_ARGS = 8;
+  static constexpr int N_REGS = 32;
+  static constexpr int N_SAVED_GPRS = 5;
+  static constexpr int N_SAVED_XMMS = 8;
+
+  static_assert(N_REGS - 1 == XMM15, "bad register count");
+
+  static RegisterInfo make_register_info();
+
+  struct Info {
+    int argument_id = -1;  // -1 if not argument
+    bool saved = false;    // does the callee save it?
+    bool special = false;  // is it a special GOAL register?
+    std::string name;
+  };
+
+  const Info& get_info(Register r) const { return m_info.at(r.id()); }
+
+  Register get_arg_reg(int id) const { return m_arg_regs.at(id); }
+
+  Register get_saved_gpr(int id) const { return m_saved_gprs.at(id); }
+
+  Register get_saved_xmm(int id) const { return m_saved_xmms.at(id); }
+
+  Register get_process_reg() const { return R13; }
+
+  Register get_st_reg() const { return R14; }
+
+  Register get_offset_reg() const { return R15; }
+
+  Register get_ret_reg() const { return RAX; }
+
+ private:
+  RegisterInfo() = default;
+  std::array<Info, N_REGS> m_info;
+  std::array<Register, N_ARGS> m_arg_regs;
+  std::array<Register, N_SAVED_GPRS> m_saved_gprs;
+  std::array<Register, N_SAVED_XMMS> m_saved_xmms;
+};
+
+}  // namespace emitter
+
+#endif  // JAK_REGISTER_H
diff --git a/goalc/emitter/registers.cpp b/goalc/emitter/registers.cpp
deleted file mode 100644
index 7fd6796d6f..0000000000
--- a/goalc/emitter/registers.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "registers.h"
-
-namespace goal {
-bool is_gpr(u8 reg) {
-  return reg <= R15;
-}
-
-u8 get_nth_xmm(u8 id) {
-  return id + XMM0;
-}
-
-bool is_xmm(u8 reg) {
-  return reg >= XMM0 && reg <= XMM15;
-}
-
-u8 xmm_to_id(u8 reg) {
-  return reg - 16;
-}
-
-}
\ No newline at end of file
diff --git a/goalc/emitter/registers.h b/goalc/emitter/registers.h
deleted file mode 100644
index 4d6892c189..0000000000
--- a/goalc/emitter/registers.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/*!
- * @file registers.h
- * Definitions and conventions for x86-64 registers.
- */
-
-#ifndef JAK1_REGISTERS_H
-#define JAK1_REGISTERS_H
-
-#include "common/common_types.h"
-
-namespace goal {
-enum X86R : u8 {
-  RAX,  // return, temp
-  RCX,  // arg 3
-  RDX,  // arg 2
-  RBX,  // X saved
-
-  RSP,  // stack pointer
-  RBP,  // X base pointer (like fp)
-  RSI,  // arg 1
-  RDI,  // arg 0
-
-  R8,   // arg 4
-  R9,   // arg 5, saved
-  R10,  // arg 6, saved (arg in GOAL only)
-  R11,  // arg 7, saved (arg in GOAL only)
-  R12,  // X saved - pp register (like s6)
-  R13,  // X saved - function call register (like t9)
-  R14,  // X saved - offset (added in GOAL x86)
-  R15,  // X saved - st (like s7)
-  XMM0,
-  XMM1,
-  XMM2,
-  XMM3,
-  XMM4,
-  XMM5,
-  XMM6,
-  XMM7,
-  XMM8,
-  XMM9,
-  XMM10,
-  XMM11,
-  XMM12,
-  XMM13,
-  XMM14,
-  XMM15
-};
-
-// the argument registers of GOAL.
-// We must have 8 to be compatible with GOAL's 8-argument function calls.
-constexpr int ARG_REG_COUNT = 8;
-
-// the first 6 are shared with Linux, and the last two are unique to GOAL.
-constexpr X86R ARG_REGS[ARG_REG_COUNT] = {
-    X86R::RDI, X86R::RSI, X86R::RDX, X86R::RCX, X86R::R8, X86R::R9, X86R::R10, X86R::R11,
-};
-
-// The saved registers of GOAL.  Note that RSP, RBP, R12, R13, R14, R15 shouldn't be changed by the
-// caller, but these are special registers and won't be allocated to hold variables.
-constexpr int SAVED_REG_COUNT = 4;
-constexpr X86R SAVED_REGS[SAVED_REG_COUNT] = {X86R::RBX, X86R::R9, X86R::R10, X86R::R11};
-
-// special registers
-constexpr X86R PP_REG = X86R::R12;
-constexpr X86R FUNC_REG = X86R::R13;
-constexpr X86R OFF_REG = X86R::R14;
-constexpr X86R ST_REG = X86R::R15;
-constexpr X86R FP_REG = X86R::RBP;
-constexpr X86R RET_REG = X86R::RAX;
-
-// size in bytes of a pointer
-constexpr int PTR_SIZE = 4;
-
-// size in bytes of a general purpose register
-constexpr int GPR_SIZE = 8;
-
-constexpr const char* x86_gpr_names[] = {
-    "rax",  "rcx",  "rdx",  "rbx",  "rsp",   "rbp",   "rsi",   "rdi",   "r8",    "r9",   "r10",
-    "r11",  "r12",  "r13",  "r14",  "r15",   "xmm0",  "xmm1",  "xmm2",  "xmm3",  "xmm4", "xmm5",
-    "xmm6", "xmm7", "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"};
-
-/*
- Name   Arg ID   Clobber?  Special
-  RAX     -         y       return
-  RCX     3         y       arg
-  RDX     2         y       arg
-  RBX     -         n
-
-  RSP     -         n       stack pointer
-  RBP     -         n       base pointer
-  RSI     1         y       arg
-  RDI     0         y       arg
-
-  R8      4         y       arg
-  R9      5         n       arg
-  R10     6         n       arg
-  R11     7         n       arg
-  R12     -         n       pp
-  R13     -         n       func
-  R14     -         n
-  R15
- */
-
-bool is_gpr(u8 reg);
-u8 get_nth_xmm(u8 id);
-bool is_xmm(u8 reg);
-u8 xmm_to_id(u8 reg);
-
-}  // namespace goal
-
-#endif  // JAK1_REGISTERS_H
diff --git a/goalc/goos/Interpreter.cpp b/goalc/goos/Interpreter.cpp
index f37ba8c1e6..285f607fbe 100644
--- a/goalc/goos/Interpreter.cpp
+++ b/goalc/goos/Interpreter.cpp
@@ -85,6 +85,13 @@ Interpreter::Interpreter() {
   load_goos_library();
 }
 
+Interpreter::~Interpreter() {
+  // There are some circular references that prevent shared_ptrs from cleaning up if we
+  // don't do this.
+  global_environment.as_env()->vars.clear();
+  goal_env.as_env()->vars.clear();
+}
+
 /*!
  * Disable printfs on errors, to make test output look less messy.
  */
diff --git a/goalc/goos/Interpreter.h b/goalc/goos/Interpreter.h
index 7d37dbe210..b19903e68e 100644
--- a/goalc/goos/Interpreter.h
+++ b/goalc/goos/Interpreter.h
@@ -15,6 +15,7 @@ namespace goos {
 class Interpreter {
  public:
   Interpreter();
+  ~Interpreter();
   void execute_repl();
   void throw_eval_error(const Object& o, const std::string& err);
   Object eval_with_rewind(const Object& obj, const std::shared_ptr<EnvironmentObject>& env);
diff --git a/goalc/listener/CMakeLists.txt b/goalc/listener/CMakeLists.txt
index 470fe89d37..f978b4d633 100644
--- a/goalc/listener/CMakeLists.txt
+++ b/goalc/listener/CMakeLists.txt
@@ -1,2 +1,2 @@
 add_library(listener SHARED
-        Listener.cpp Deci2Server.cpp Deci2Server.h)
+        Listener.cpp)
diff --git a/goalc/listener/Deci2Server.cpp b/goalc/listener/Deci2Server.cpp
deleted file mode 100644
index be9732b917..0000000000
--- a/goalc/listener/Deci2Server.cpp
+++ /dev/null
@@ -1,270 +0,0 @@
-
-
-
-
-/*!
- * @file Deci2Server.cpp
- * Basic implementation of a DECI2 server.
- * Works with deci2.cpp (sceDeci2) to implement the networking on target
- */
-#ifdef __unix__
-#include <cstdio>
-#include <sys/socket.h>
-#include <netinet/tcp.h>
-#include <unistd.h>
-#include <cassert>
-#include <utility>
-
-#include "common/listener_common.h"
-#include "common/versions.h"
-#include "Deci2Server.h"
-
-Deci2Server::Deci2Server(std::function<bool()> shutdown_callback) {
-  buffer = new char[BUFFER_SIZE];
-  want_exit = std::move(shutdown_callback);
-}
-
-Deci2Server::~Deci2Server() {
-  // if accept thread is running, kill it
-  if (accept_thread_running) {
-    kill_accept_thread = true;
-    accept_thread.join();
-    accept_thread_running = false;
-  }
-
-  delete[] buffer;
-
-  if (server_fd >= 0) {
-    close(server_fd);
-  }
-
-  if (new_sock >= 0) {
-    close(new_sock);
-  }
-}
-
-/*!
- * Start waiting for the Listener to connect
- 
-bool Deci2Server::init() {
-  server_fd = socket(AF_INET, SOCK_STREAM, 0);
-  if (server_fd < 0) {
-    server_fd = -1;
-    return false;
-  }
-
-  int opt = 1;
-  if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
-    printf("[Deci2Server] Failed to setsockopt 1\n");
-    close(server_fd);
-    server_fd = -1;
-    return false;
-  }
-
-  int one = 1;
-  if (setsockopt(server_fd, SOL_TCP, TCP_NODELAY, &one, sizeof(one))) {
-    printf("[Deci2Server] Failed to setsockopt 2\n");
-    close(server_fd);
-    server_fd = -1;
-    return false;
-  }
-
-  timeval timeout = {};
-  timeout.tv_sec = 0;
-  timeout.tv_usec = 100000;
-
-  if (setsockopt(server_fd, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(timeout)) < 0) {
-    printf("[Deci2Server] Failed to setsockopt 3\n");
-    close(server_fd);
-    server_fd = -1;
-    return false;
-  }
-
-  addr.sin_family = AF_INET;
-  addr.sin_addr.s_addr = INADDR_ANY;
-  addr.sin_port = htons(DECI2_PORT);
-
-  if (bind(server_fd, (sockaddr*)&addr, sizeof(addr)) < 0) {
-    printf("[Deci2Server] Failed to bind\n");
-    close(server_fd);
-    server_fd = -1;
-    return false;
-  }
-
-  if (listen(server_fd, 0) < 0) {
-    printf("[Deci2Server] Failed to listen\n");
-    close(server_fd);
-    server_fd = -1;
-    return false;
-  }
-
-  server_initialized = true;
-  accept_thread_running = true;
-  kill_accept_thread = false;
-  accept_thread = std::thread(&Deci2Server::accept_thread_func, this);
-  return true;
-}
-
-/*!
- * Return true if the listener is connected.
- 
-bool Deci2Server::check_for_listener() {
-  if (server_connected) {
-    if (accept_thread_running) {
-      accept_thread.join();
-      accept_thread_running = false;
-    }
-    return true;
-  } else {
-    return false;
-  }
-}
-
-/*!
- * Send data from buffer. User must provide appropriate headers.
- 
-void Deci2Server::send_data(void* buf, u16 len) {
-  lock();
-  if (!server_connected) {
-    printf("[DECI2] send while not connected, not sending!\n");
-  } else {
-    uint16_t prog = 0;
-    while (prog < len) {
-      auto wrote = write(new_sock, (char*)(buf) + prog, len - prog);
-      prog += wrote;
-      if (!server_connected || want_exit()) {
-        unlock();
-        return;
-      }
-    }
-  }
-  unlock();
-}
-
-/*!
- * Lock the DECI mutex. Should be done before modifying protocols.
- 
-void Deci2Server::lock() {
-  deci_mutex.lock();
-}
-
-/*!
- * Unlock the DECI mutex. Should be done after modifying protocols.
-
-void Deci2Server::unlock() {
-  deci_mutex.unlock();
-}
-
-/*!
- * Wait for protocols to become ready.
- * This avoids the case where we receive messages before protocol handlers are set up.
- 
-void Deci2Server::wait_for_protos_ready() {
-  if (protocols_ready)
-    return;
-  std::unique_lock<std::mutex> lk(deci_mutex);
-  cv.wait(lk, [&] { return protocols_ready; });
-}
-
-/*!
- * Inform server that protocol handlers are ready.
- * Will unblock wait_for_protos_ready and incoming messages will be dispatched to these
- * protocols.  You can change the protocol handlers, but you should lock the mutex before
- * doing so.
- 
-void Deci2Server::send_proto_ready(Deci2Driver* drivers, int* driver_count) {
-  lock();
-  d2_drivers = drivers;
-  d2_driver_count = driver_count;
-  protocols_ready = true;
-  unlock();
-  cv.notify_all();
-}
-
-void Deci2Server::run() {
-  int desired_size = (int)sizeof(Deci2Header);
-  int got = 0;
-
-  while (got < desired_size) {
-    assert(got + desired_size < BUFFER_SIZE);
-    auto x = read(new_sock, buffer + got, desired_size - got);
-    if (want_exit()) {
-      return;
-    }
-    got += x > 0 ? x : 0;
-  }
-
-  auto* hdr = (Deci2Header*)(buffer);
-  printf("[DECI2] Got message:\n");
-  printf(" %d %d 0x%x %c -> %c\n", hdr->len, hdr->rsvd, hdr->proto, hdr->src, hdr->dst);
-
-  hdr->rsvd = got;
-
-  // see what protocol we got:
-  lock();
-
-  int handler = -1;
-  for (int i = 0; i < *d2_driver_count; i++) {
-    auto& prot = d2_drivers[i];
-    if (prot.active && prot.protocol) {
-      if (handler != -1) {
-        printf("[DECI2] Warning: more than on protocol handler for this message!\n");
-      }
-      handler = i;
-    }
-  }
-
-  if (handler == -1) {
-    printf("[DECI2] Warning: no handler for this message, ignoring...\n");
-    unlock();
-    return;
-    //    throw std::runtime_error("no handler!");
-  }
-
-  auto& driver = d2_drivers[handler];
-
-  int sent_to_program = 0;
-  while (!want_exit() && (hdr->rsvd < hdr->len || sent_to_program < hdr->rsvd)) {
-    // send what we have to the program
-    if (sent_to_program < hdr->rsvd) {
-      //      driver.next_recv_size = 0;
-      //      driver.next_recv = nullptr;
-      driver.recv_buffer = buffer + sent_to_program;
-      driver.available_to_receive = hdr->rsvd - sent_to_program;
-      (driver.handler)(DECI2_READ, driver.available_to_receive, driver.opt);
-      //      memcpy(driver.next_recv, buffer + sent_to_program, driver.next_recv_size);
-      sent_to_program += driver.recv_size;
-    }
-
-    // receive from network
-    if (hdr->rsvd < hdr->len) {
-      auto x = read(new_sock, buffer + hdr->rsvd, hdr->len - hdr->rsvd);
-      if (want_exit()) {
-        return;
-      }
-      got += x > 0 ? x : 0;
-      hdr->rsvd += got;
-    }
-  }
-
-  (driver.handler)(DECI2_READDONE, 0, driver.opt);
-  unlock();
-}
-
-/*!
- * Background thread for waiting for the listener.
- 
-void Deci2Server::accept_thread_func() {
-  socklen_t l = sizeof(addr);
-  while (!kill_accept_thread) {
-    new_sock = accept(server_fd, (sockaddr*)&addr, &l);
-    if (new_sock >= 0) {
-      u32 versions[2] = {versions::GOAL_VERSION_MAJOR, versions::GOAL_VERSION_MINOR};
-      send(new_sock, &versions, 8, 0);  // todo, check result?
-      server_connected = true;
-      return;
-    }
-  }
-}
-
-#endif
\ No newline at end of file
diff --git a/goalc/listener/Deci2Server.h b/goalc/listener/Deci2Server.h
deleted file mode 100644
index c07e649711..0000000000
--- a/goalc/listener/Deci2Server.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*!
- * @file Deci2Server.h
- * Basic implementation of a DECI2 server.
- * Works with deci2.cpp (sceDeci2) to implement the networking on target
- 
-
-#ifndef JAK1_DECI2SERVER_H
-#define JAK1_DECI2SERVER_H
-
-#include <netinet/in.h>
-#include <thread>
-#include <mutex>
-#include <condition_variable>
-#include <functional>
-#include "game/system/deci_common.h" // todo, move me!
-
-
-class Deci2Server {
- public:
-  static constexpr int BUFFER_SIZE = 32 * 1024 * 1024;
-  Deci2Server(std::function<bool()> shutdown_callback);
-  ~Deci2Server();
-  bool init();
-  bool check_for_listener();
-  void send_data(void* buf, u16 len);
-
-  void lock();
-  void unlock();
-  void wait_for_protos_ready();
-  void send_proto_ready(Deci2Driver* drivers, int* driver_count);
-
-  void run();
-
-
- private:
-  void accept_thread_func();
-  bool kill_accept_thread = false;
-  char* buffer = nullptr;
-  int server_fd;
-  sockaddr_in addr;
-  int new_sock;
-  bool server_initialized = false;
-  bool accept_thread_running = false;
-  bool server_connected = false;
-  std::function<bool()> want_exit;
-  std::thread accept_thread;
-
-  std::condition_variable cv;
-  bool protocols_ready = false;
-  std::mutex deci_mutex;
-  Deci2Driver* d2_drivers = nullptr;
-  int* d2_driver_count = nullptr;
-};
-
-
-
-#endif  // JAK1_DECI2SERVER_H
-
-*/
diff --git a/goalc/listener/Listener.h b/goalc/listener/Listener.h
index 0b5bb59eaa..5ae49e2f5f 100644
--- a/goalc/listener/Listener.h
+++ b/goalc/listener/Listener.h
@@ -25,12 +25,11 @@ class Listener {
   bool is_connected() const;
   void disconnect();
 
-
  private:
-  char* m_buffer = nullptr; //! buffer for incoming messages
-  bool m_connected = false; //! do we think we are connected?
-  bool receive_thread_running = false; //! is the receive thread unjoined?
-  int socket_fd = -1; //! socket
+  char* m_buffer = nullptr;             //! buffer for incoming messages
+  bool m_connected = false;             //! do we think we are connected?
+  bool receive_thread_running = false;  //! is the receive thread unjoined?
+  int socket_fd = -1;                   //! socket
   bool got_ack = false;
   bool waiting_for_ack = false;
 
@@ -41,7 +40,6 @@ class Listener {
   std::vector<std::string> message_record;
   char ack_recv_buff[512];
 };
-}
-
+}  // namespace listener
 
 #endif  // JAK1_LISTENER_H
diff --git a/goalc/main.cpp b/goalc/main.cpp
index 8ff9026a5e..57d145c069 100644
--- a/goalc/main.cpp
+++ b/goalc/main.cpp
@@ -11,4 +11,3 @@ int main(int argc, char** argv) {
 
   return 0;
 }
-
diff --git a/goalc/util/text_util.cpp b/goalc/util/text_util.cpp
index 9c6c94b0bb..9139c06584 100644
--- a/goalc/util/text_util.cpp
+++ b/goalc/util/text_util.cpp
@@ -13,4 +13,4 @@ namespace util {
 bool is_printable_char(char c) {
   return c >= ' ' && c <= '~';
 }
-}
+}  // namespace util
diff --git a/test.sh b/test.sh
index aa21329103..3cff7a5976 100755
--- a/test.sh
+++ b/test.sh
@@ -4,4 +4,4 @@
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 
 export NEXT_DIR=$DIR
-$DIR/build/test/goalc-test "$@"
\ No newline at end of file
+$DIR/build/test/goalc-test --gtest_color=yes "$@"
\ No newline at end of file
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 71cae58cef..d1d0a912e9 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -6,11 +6,15 @@ add_executable(goalc-test
         test_reader.cpp
         test_goos.cpp
         test_listener_deci2.cpp
-		all_jak1_symbols.cpp
-        #test_kernel.cpp
-        #test_CodeTester.cpp
-        #test_type_system.cpp
-)
+        test_kernel.cpp
+        all_jak1_symbols.cpp
+        test_type_system.cpp
+        test_CodeTester.cpp
+        test_emitter_slow.cpp
+        test_emitter_loads_and_store.cpp
+        test_emitter_xmm32.cpp
+        test_emitter_integer_math.cpp
+        )
 
 IF (WIN32)
 	set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
diff --git a/test/test_CodeTester.cpp b/test/test_CodeTester.cpp
index c5e1ba832a..04a56ab8a4 100644
--- a/test/test_CodeTester.cpp
+++ b/test/test_CodeTester.cpp
@@ -2,13 +2,16 @@
  * @file test_CodeTester.cpp
  * Tests for the CodeTester, a tool for testing the emitter by emitting code and running it
  * from within the test application.
+ *
+ * These tests should just make sure the basic functionality of CodeTester works, and that it
+ * can generate prologues/epilogues, and execute them without crashing.
  */
 
 #include "gtest/gtest.h"
 #include "goalc/emitter/CodeTester.h"
 #include "goalc/emitter/IGen.h"
 
-using namespace goal;
+using namespace emitter;
 
 TEST(CodeTester, prologue) {
   CodeTester tester;
@@ -47,121 +50,120 @@ TEST(CodeTester, execute_push_pop_gprs) {
   tester.execute();
 }
 
-TEST(CodeTester, load_constant_64_and_move_gpr_gpr_64) {
-  std::vector<u64> u64_constants = {0, UINT64_MAX, INT64_MAX, 7, 12};
-
-  // test we can load a 64-bit constant into all gprs, move it to any other gpr, and return it.
-  // rsp is skipping because that's the stack pointer and would prevent us from popping gprs after
-
+TEST(CodeTester, xmm_store_128) {
   CodeTester tester;
   tester.init_code_buffer(256);
+  //  movdqa [rbx], xmm3
+  //  movdqa [r14], xmm3
+  //  movdqa [rbx], xmm14
+  //  movdqa [r14], xmm13
+  tester.emit(IGen::store128_gpr64_xmm128(RBX, XMM3));
+  tester.emit(IGen::store128_gpr64_xmm128(R14, XMM3));
+  tester.emit(IGen::store128_gpr64_xmm128(RBX, XMM14));
+  tester.emit(IGen::store128_gpr64_xmm128(R14, XMM13));
+  EXPECT_EQ(tester.dump_to_hex_string(),
+            "66 0f 7f 1b 66 41 0f 7f 1e 66 44 0f 7f 33 66 45 0f 7f 2e");
 
-  for (auto constant : u64_constants) {
-    for (int r1 = 0; r1 < 16; r1++) {
-      if (r1 == RSP) {
-        continue;
-      }
+  tester.clear();
+  tester.emit(IGen::store128_gpr64_xmm128(RSP, XMM1));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 0f 7f 0c 24");  // requires SIB byte.
 
-      for (int r2 = 0; r2 < 16; r2++) {
-        if (r2 == RSP) {
-          continue;
-        }
-        tester.clear();
-        tester.emit_push_all_gprs(true);
-        tester.emit(IGen::mov_gpr64_u64(r1, constant));
-        tester.emit(IGen::mov_gpr64_gpr64(r2, r1));
-        tester.emit(IGen::mov_gpr64_gpr64(RAX, r2));
-        tester.emit_pop_all_gprs(true);
-        tester.emit_return();
-        EXPECT_EQ(tester.execute(), constant);
-      }
-    }
-  }
+  tester.clear();
+  tester.emit(IGen::store128_gpr64_xmm128(R12, XMM13));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 45 0f 7f 2c 24");  // requires SIB byte and REX byte
+
+  tester.clear();
+  tester.emit(IGen::store128_gpr64_xmm128(RBP, XMM1));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 0f 7f 4d 00");
+
+  tester.clear();
+  tester.emit(IGen::store128_gpr64_xmm128(RBP, XMM11));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 44 0f 7f 5d 00");
+
+  tester.clear();
+  tester.emit(IGen::store128_gpr64_xmm128(R13, XMM2));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 41 0f 7f 55 00");
+
+  tester.clear();
+  tester.emit(IGen::store128_gpr64_xmm128(R13, XMM12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 45 0f 7f 65 00");
 }
 
-TEST(CodeTester, load_constant_32_unsigned) {
-  std::vector<u64> u64_constants = {0, UINT32_MAX, INT32_MAX, 7, 12};
-
-  // test loading 32-bit constants, with all upper 32-bits zero.
-  // this uses a different opcode than 64-bit loads.
+TEST(CodeTester, sub_gpr64_imm8) {
   CodeTester tester;
   tester.init_code_buffer(256);
-
-  for (auto constant : u64_constants) {
-    for (int r1 = 0; r1 < 16; r1++) {
-      if (r1 == RSP) {
-        continue;
-      }
-
-      tester.clear();
-      tester.emit_push_all_gprs(true);
-      tester.emit(IGen::mov_gpr64_u32(r1, constant));
-      tester.emit(IGen::mov_gpr64_gpr64(RAX, r1));
-      tester.emit_pop_all_gprs(true);
-      tester.emit_return();
-      EXPECT_EQ(tester.execute(), constant);
-    }
+  for (int i = 0; i < 16; i++) {
+    tester.emit(IGen::sub_gpr64_imm8s(i, -1));
   }
+  EXPECT_EQ(tester.dump_to_hex_string(true),
+            "4883E8FF4883E9FF4883EAFF4883EBFF4883ECFF4883EDFF4883EEFF4883EFFF4983E8FF4983E9FF4983EA"
+            "FF4983EBFF4983ECFF4983EDFF4983EEFF4983EFFF");
 }
 
-TEST(CodeTester, load_constant_32_signed) {
-  std::vector<s32> s32_constants = {0, 1, INT32_MAX, INT32_MIN, 12, -1};
-
-  // test loading signed 32-bit constants.  for values < 0 this will sign extend.
+TEST(CodeTester, add_gpr64_imm8) {
   CodeTester tester;
   tester.init_code_buffer(256);
-
-  for (auto constant : s32_constants) {
-    for (int r1 = 0; r1 < 16; r1++) {
-      if (r1 == RSP) {
-        continue;
-      }
-
-      tester.clear();
-      tester.emit_push_all_gprs(true);
-      tester.emit(IGen::mov_gpr64_s32(r1, constant));
-      tester.emit(IGen::mov_gpr64_gpr64(RAX, r1));
-      tester.emit_pop_all_gprs(true);
-      tester.emit_return();
-      EXPECT_EQ(tester.execute(), constant);
-    }
+  for (int i = 0; i < 16; i++) {
+    tester.emit(IGen::add_gpr64_imm8s(i, -1));
   }
+  EXPECT_EQ(tester.dump_to_hex_string(true),
+            "4883C0FF4883C1FF4883C2FF4883C3FF4883C4FF4883C5FF4883C6FF4883C7FF4983C0FF4983C1FF4983C2"
+            "FF4983C3FF4983C4FF4983C5FF4983C6FF4983C7FF");
 }
 
-TEST(CodeTester, xmm_move) {
-  std::vector<u32> u32_constants = {0, INT32_MAX, UINT32_MAX, 17};
-
-  // test moving between xmms (32-bit) and gprs.
+TEST(CodeTester, xmm_load_128) {
   CodeTester tester;
   tester.init_code_buffer(256);
+  tester.emit(IGen::load128_xmm128_gpr64(XMM3, RBX));
+  tester.emit(IGen::load128_xmm128_gpr64(XMM3, R14));
+  tester.emit(IGen::load128_xmm128_gpr64(XMM14, RBX));
+  tester.emit(IGen::load128_xmm128_gpr64(XMM13, R14));
+  EXPECT_EQ(tester.dump_to_hex_string(),
+            "66 0f 6f 1b 66 41 0f 6f 1e 66 44 0f 6f 33 66 45 0f 6f 2e");
 
-  for(auto constant : u32_constants) {
-    for(int r1 = 0; r1 < 16; r1++) {
-      if(r1 == RSP) {
-        continue;
-      }
-      for(int r2 = 0; r2 < 16; r2++) {
-        if(r2 == RSP) {
-          continue;
-        }
-        for(int r3 = 0; r3 < 16; r3++) {
-          for(int r4 = 0; r4 < 16; r4++) {
-            tester.clear();
-            tester.emit_push_all_gprs(true);
-            // move constant to gpr
-            tester.emit(IGen::mov_gpr64_u32(r1, constant));
-            // move gpr to xmm
-            tester.emit(IGen::movd_xmm32_gpr32(get_nth_xmm(r3), r1));
-            // move xmm to xmm
-            tester.emit(IGen::mov_xmm32_xmm32(get_nth_xmm(r4), get_nth_xmm(r3)));
-            // move xmm to gpr
-            tester.emit(IGen::movd_gpr32_xmm32(r2, get_nth_xmm(r4)));
-            // return!
-            tester.emit(IGen::mov_gpr64_gpr64(RAX, r2));
-            tester.emit_return();
-          }
-        }
-      }
-    }
-  }
-}
\ No newline at end of file
+  tester.clear();
+  tester.emit(IGen::load128_xmm128_gpr64(XMM1, RSP));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 0f 6f 0c 24");  // requires SIB byte.
+
+  tester.clear();
+  tester.emit(IGen::load128_xmm128_gpr64(XMM13, R12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 45 0f 6f 2c 24");  // requires SIB byte and REX byte
+
+  tester.clear();
+  tester.emit(IGen::load128_xmm128_gpr64(XMM1, RBP));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 0f 6f 4d 00");
+
+  tester.clear();
+  tester.emit(IGen::load128_xmm128_gpr64(XMM11, RBP));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 44 0f 6f 5d 00");
+
+  tester.clear();
+  tester.emit(IGen::load128_xmm128_gpr64(XMM2, R13));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 41 0f 6f 55 00");
+
+  tester.clear();
+  tester.emit(IGen::load128_xmm128_gpr64(XMM12, R13));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 45 0f 6f 65 00");
+}
+
+TEST(CodeTester, push_pop_xmms) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+  tester.emit_push_all_xmms();
+  tester.emit_pop_all_xmms();
+  tester.emit_return();
+  tester.execute();
+}
+
+TEST(CodeTester, push_pop_all_the_things) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+  tester.emit_push_all_xmms();
+  tester.emit_push_all_gprs();
+
+  // ...
+  tester.emit_pop_all_gprs();
+  tester.emit_pop_all_xmms();
+  tester.emit_return();
+  tester.execute();
+}
diff --git a/test/test_emitter_integer_math.cpp b/test/test_emitter_integer_math.cpp
new file mode 100644
index 0000000000..1eb8dd926a
--- /dev/null
+++ b/test/test_emitter_integer_math.cpp
@@ -0,0 +1,628 @@
+#include "third-party/fmt/core.h"
+#include "gtest/gtest.h"
+#include "goalc/emitter/CodeTester.h"
+#include "goalc/emitter/IGen.h"
+
+using namespace emitter;
+
+TEST(EmitterIntegerMath, add_gpr64_imm8s) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+
+  std::vector<s64> vals = {0, 1, -1, INT32_MIN, INT32_MAX, INT64_MIN, INT64_MAX};
+  std::vector<s64> imms = {0, 1, -1, INT8_MIN, INT8_MAX};
+
+  // test the ones that aren't rsp
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (auto val : vals) {
+      for (auto imm : imms) {
+        auto expected = val + imm;
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+
+        // move initial value to register
+        tester.emit(IGen::mov_gpr64_gpr64(i, tester.get_c_abi_arg_reg(0)));
+        // do the add
+        tester.emit(IGen::add_gpr64_imm8s(i, imm));
+        // move for return
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        auto result = tester.execute_ret<s64>(val, 0, 0, 0);
+        EXPECT_EQ(result, expected);
+      }
+    }
+  }
+
+  tester.clear();
+  tester.emit(IGen::add_gpr64_imm8s(RSP, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 83 c4 0c");
+}
+
+TEST(EmitterIntegerMath, add_gpr64_imm32s) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+
+  std::vector<s64> vals = {0, 1, -1, INT32_MIN, INT32_MAX, INT64_MIN, INT64_MAX};
+  std::vector<s64> imms = {0, 1, -1, INT8_MIN, INT8_MAX, INT32_MIN, INT32_MAX};
+
+  // test the ones that aren't rsp
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (auto val : vals) {
+      for (auto imm : imms) {
+        auto expected = val + imm;
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+
+        // move initial value to register
+        tester.emit(IGen::mov_gpr64_gpr64(i, tester.get_c_abi_arg_reg(0)));
+        // do the add
+        tester.emit(IGen::add_gpr64_imm32s(i, imm));
+        // move for return
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        auto result = tester.execute_ret<s64>(val, 0, 0, 0);
+        EXPECT_EQ(result, expected);
+      }
+    }
+  }
+
+  tester.clear();
+  tester.emit(IGen::add_gpr64_imm32s(RSP, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 81 c4 0c 00 00 00");
+}
+
+TEST(EmitterIntegerMath, sub_gpr64_imm8s) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+
+  std::vector<s64> vals = {0, 1, -1, INT32_MIN, INT32_MAX, INT64_MIN, INT64_MAX};
+  std::vector<s64> imms = {0, 1, -1, INT8_MIN, INT8_MAX};
+
+  // test the ones that aren't rsp
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (auto val : vals) {
+      for (auto imm : imms) {
+        auto expected = val - imm;
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+
+        // move initial value to register
+        tester.emit(IGen::mov_gpr64_gpr64(i, tester.get_c_abi_arg_reg(0)));
+        // do the add
+        tester.emit(IGen::sub_gpr64_imm8s(i, imm));
+        // move for return
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        auto result = tester.execute_ret<s64>(val, 0, 0, 0);
+        EXPECT_EQ(result, expected);
+      }
+    }
+  }
+
+  tester.clear();
+  tester.emit(IGen::sub_gpr64_imm8s(RSP, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 83 ec 0c");
+}
+
+TEST(EmitterIntegerMath, sub_gpr64_imm32s) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+
+  std::vector<s64> vals = {0, 1, -1, INT32_MIN, INT32_MAX, INT64_MIN, INT64_MAX};
+  std::vector<s64> imms = {0, 1, -1, INT8_MIN, INT8_MAX, INT32_MIN, INT32_MAX};
+
+  // test the ones that aren't rsp
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (auto val : vals) {
+      for (auto imm : imms) {
+        auto expected = val - imm;
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+
+        // move initial value to register
+        tester.emit(IGen::mov_gpr64_gpr64(i, tester.get_c_abi_arg_reg(0)));
+        // do the add
+        tester.emit(IGen::sub_gpr64_imm32s(i, imm));
+        // move for return
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        auto result = tester.execute_ret<s64>(val, 0, 0, 0);
+        EXPECT_EQ(result, expected);
+      }
+    }
+  }
+
+  tester.clear();
+  tester.emit(IGen::sub_gpr64_imm32s(RSP, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 81 ec 0c 00 00 00");
+}
+
+TEST(EmitterIntegerMath, add_gpr64_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  std::vector<s64> vals = {0,         1,   -2, INT32_MIN, INT32_MAX, INT64_MIN,
+                           INT64_MAX, 117, 32, -348473,   83747382};
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+      for (auto v1 : vals) {
+        for (auto v2 : vals) {
+          auto expected = v1 + v2;
+          tester.clear();
+          tester.emit_push_all_gprs(true);
+          tester.emit(IGen::mov_gpr64_u64(i, v1));
+          tester.emit(IGen::mov_gpr64_u64(j, v2));
+          tester.emit(IGen::add_gpr64_gpr64(i, j));
+          tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+          tester.emit_pop_all_gprs(true);
+          tester.emit_return();
+          auto result = tester.execute_ret<s64>(0, 0, 0, 0);
+          EXPECT_EQ(result, expected);
+        }
+      }
+    }
+  }
+}
+
+TEST(EmitterIntegerMath, sub_gpr64_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  std::vector<s64> vals = {0,         1,   -2, INT32_MIN, INT32_MAX, INT64_MIN,
+                           INT64_MAX, 117, 32, -348473,   83747382};
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+      for (auto v1 : vals) {
+        for (auto v2 : vals) {
+          auto expected = v1 - v2;
+          tester.clear();
+          tester.emit_push_all_gprs(true);
+          tester.emit(IGen::mov_gpr64_u64(i, v1));
+          tester.emit(IGen::mov_gpr64_u64(j, v2));
+          tester.emit(IGen::sub_gpr64_gpr64(i, j));
+          tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+          tester.emit_pop_all_gprs(true);
+          tester.emit_return();
+          auto result = tester.execute_ret<s64>(0, 0, 0, 0);
+          EXPECT_EQ(result, expected);
+        }
+      }
+    }
+  }
+}
+
+TEST(EmitterIntegerMath, mul_gpr32_gpr32) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  std::vector<s32> vals = {
+      0, 1, -2, -20, 123123, INT32_MIN, INT32_MAX, INT32_MIN + 1, INT32_MAX - 1};
+
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+      for (auto v1 : vals) {
+        for (auto v2 : vals) {
+          // this is kind of weird behavior, but it's what the PS2 CPU does, I think.
+          // the lower 32-bits of the result are sign extended, even if this sign doesn't match
+          // the sign of the real product.  This is true for both signed and unsigned multiply.
+          auto expected = ((s64(v1) * s64(v2)) << 32) >> 32;
+          tester.clear();
+          tester.emit_push_all_gprs(true);
+          tester.emit(IGen::mov_gpr64_u64(i, (s64)v1));
+          tester.emit(IGen::mov_gpr64_u64(j, (s64)v2));
+          tester.emit(IGen::imul_gpr32_gpr32(i, j));
+          tester.emit(IGen::movsx_r64_r32(RAX, i));  // weird PS2 sign extend.
+          tester.emit_pop_all_gprs(true);
+          tester.emit_return();
+          auto result = tester.execute_ret<s64>(0, 0, 0, 0);
+          EXPECT_EQ(result, expected);
+          if (result != expected) {
+            fmt::print("fail {} x {}: {}\n", v1, v2, tester.dump_to_hex_string());
+          }
+        }
+      }
+    }
+  }
+}
+
+TEST(EmitterIntegerMath, or_gpr64_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  std::vector<s64> vals = {0,         1,   -2, INT32_MIN, INT32_MAX, INT64_MIN,
+                           INT64_MAX, 117, 32, -348473,   83747382};
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+      for (auto v1 : vals) {
+        for (auto v2 : vals) {
+          auto expected = v1 | v2;
+          tester.clear();
+          tester.emit_push_all_gprs(true);
+          tester.emit(IGen::mov_gpr64_u64(i, v1));
+          tester.emit(IGen::mov_gpr64_u64(j, v2));
+          tester.emit(IGen::or_gpr64_gpr64(i, j));
+          tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+          tester.emit_pop_all_gprs(true);
+          tester.emit_return();
+          auto result = tester.execute_ret<s64>(0, 0, 0, 0);
+          EXPECT_EQ(result, expected);
+        }
+      }
+    }
+  }
+}
+
+TEST(EmitterIntegerMath, and_gpr64_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  std::vector<s64> vals = {0,         1,   -2, INT32_MIN, INT32_MAX, INT64_MIN,
+                           INT64_MAX, 117, 32, -348473,   83747382};
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+      for (auto v1 : vals) {
+        for (auto v2 : vals) {
+          auto expected = v1 & v2;
+          tester.clear();
+          tester.emit_push_all_gprs(true);
+          tester.emit(IGen::mov_gpr64_u64(i, v1));
+          tester.emit(IGen::mov_gpr64_u64(j, v2));
+          tester.emit(IGen::and_gpr64_gpr64(i, j));
+          tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+          tester.emit_pop_all_gprs(true);
+          tester.emit_return();
+          auto result = tester.execute_ret<s64>(0, 0, 0, 0);
+          EXPECT_EQ(result, expected);
+        }
+      }
+    }
+  }
+}
+
+TEST(EmitterIntegerMath, xor_gpr64_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  std::vector<s64> vals = {0,         1,   -2, INT32_MIN, INT32_MAX, INT64_MIN,
+                           INT64_MAX, 117, 32, -348473,   83747382};
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+      for (auto v1 : vals) {
+        for (auto v2 : vals) {
+          auto expected = v1 ^ v2;
+          tester.clear();
+          tester.emit_push_all_gprs(true);
+          tester.emit(IGen::mov_gpr64_u64(i, v1));
+          tester.emit(IGen::mov_gpr64_u64(j, v2));
+          tester.emit(IGen::xor_gpr64_gpr64(i, j));
+          tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+          tester.emit_pop_all_gprs(true);
+          tester.emit_return();
+          auto result = tester.execute_ret<s64>(0, 0, 0, 0);
+          EXPECT_EQ(result, expected);
+        }
+      }
+    }
+  }
+}
+
+TEST(EmitterIntegerMath, not_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  std::vector<s64> vals = {0,         1,   -2, INT32_MIN, INT32_MAX, INT64_MIN,
+                           INT64_MAX, 117, 32, -348473,   83747382};
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (auto v1 : vals) {
+      auto expected = ~v1;
+      tester.clear();
+      tester.emit_push_all_gprs(true);
+      tester.emit(IGen::mov_gpr64_u64(i, v1));
+      tester.emit(IGen::not_gpr64(i));
+      tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+      tester.emit_pop_all_gprs(true);
+      tester.emit_return();
+      auto result = tester.execute_ret<s64>(0, 0, 0, 0);
+      EXPECT_EQ(result, expected);
+    }
+  }
+}
+
+TEST(EmitterIntegerMath, shl_gpr64_cl) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  std::vector<s64> vals = {0,         1,   -2, INT32_MIN, INT32_MAX, INT64_MIN,
+                           INT64_MAX, 117, 32, -348473,   83747382};
+  std::vector<u8> sas = {0, 1, 23, 53, 64};
+
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP || i == RCX) {
+      continue;
+    }
+    for (auto v : vals) {
+      for (auto sa : sas) {
+        auto expected = v << sa;
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        tester.emit(IGen::mov_gpr64_u64(i, v));
+        tester.emit(IGen::mov_gpr64_u64(RCX, sa));
+        tester.emit(IGen::shl_gpr64_cl(i));
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+        auto result = tester.execute_ret<s64>(0, 0, 0, 0);
+        EXPECT_EQ(result, expected);
+      }
+    }
+  }
+}
+
+TEST(EmitterIntegerMath, shr_gpr64_cl) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  std::vector<u64> vals = {0,         1,   u64(-2), u64(INT32_MIN), INT32_MAX, u64(INT64_MIN),
+                           INT64_MAX, 117, 32,      u64(-348473),   83747382};
+  std::vector<u8> sas = {0, 1, 23, 53, 64};
+
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP || i == RCX) {
+      continue;
+    }
+    for (auto v : vals) {
+      for (auto sa : sas) {
+        auto expected = v >> sa;
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        tester.emit(IGen::mov_gpr64_u64(i, v));
+        tester.emit(IGen::mov_gpr64_u64(RCX, sa));
+        tester.emit(IGen::shr_gpr64_cl(i));
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+        auto result = tester.execute_ret<s64>(0, 0, 0, 0);
+        EXPECT_EQ(result, expected);
+      }
+    }
+  }
+}
+
+TEST(EmitterIntegerMath, sar_gpr64_cl) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  std::vector<s64> vals = {0,         1,   -2, INT32_MIN, INT32_MAX, INT64_MIN,
+                           INT64_MAX, 117, 32, -348473,   83747382};
+  std::vector<u8> sas = {0, 1, 23, 53, 64};
+
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP || i == RCX) {
+      continue;
+    }
+    for (auto v : vals) {
+      for (auto sa : sas) {
+        auto expected = v >> sa;
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        tester.emit(IGen::mov_gpr64_u64(i, v));
+        tester.emit(IGen::mov_gpr64_u64(RCX, sa));
+        tester.emit(IGen::sar_gpr64_cl(i));
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+        auto result = tester.execute_ret<s64>(0, 0, 0, 0);
+        EXPECT_EQ(result, expected);
+      }
+    }
+  }
+}
+
+TEST(EmitterIntegerMath, shl_gpr64_u8) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  std::vector<s64> vals = {0,         1,   -2, INT32_MIN, INT32_MAX, INT64_MIN,
+                           INT64_MAX, 117, 32, -348473,   83747382};
+  std::vector<u8> sas = {0, 1, 23, 53, 64};
+
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (auto v : vals) {
+      for (auto sa : sas) {
+        auto expected = v << sa;
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        tester.emit(IGen::mov_gpr64_u64(i, v));
+        tester.emit(IGen::shl_gpr64_u8(i, sa));
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+        auto result = tester.execute_ret<s64>(0, 0, 0, 0);
+        EXPECT_EQ(result, expected);
+      }
+    }
+  }
+}
+
+TEST(EmitterIntegerMath, shr_gpr64_u8) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  std::vector<u64> vals = {0,         1,   u64(-2), u64(INT32_MIN), INT32_MAX, u64(INT64_MIN),
+                           INT64_MAX, 117, 32,      u64(-348473),   83747382};
+  std::vector<u8> sas = {0, 1, 23, 53, 64};
+
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (auto v : vals) {
+      for (auto sa : sas) {
+        auto expected = v >> sa;
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        tester.emit(IGen::mov_gpr64_u64(i, v));
+        tester.emit(IGen::shr_gpr64_u8(i, sa));
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+        auto result = tester.execute_ret<s64>(0, 0, 0, 0);
+        EXPECT_EQ(result, expected);
+      }
+    }
+  }
+}
+
+TEST(EmitterIntegerMath, sar_gpr64_u8) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  std::vector<s64> vals = {0,         1,   -2, INT32_MIN, INT32_MAX, INT64_MIN,
+                           INT64_MAX, 117, 32, -348473,   83747382};
+  std::vector<u8> sas = {0, 1, 23, 53, 64};
+
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (auto v : vals) {
+      for (auto sa : sas) {
+        auto expected = v >> sa;
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        tester.emit(IGen::mov_gpr64_u64(i, v));
+        tester.emit(IGen::sar_gpr64_u8(i, sa));
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+        auto result = tester.execute_ret<s64>(0, 0, 0, 0);
+        EXPECT_EQ(result, expected);
+      }
+    }
+  }
+}
+
+TEST(EmitterIntegerMath, jumps) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+
+  std::vector<int> reads;
+
+  auto x = IGen::jmp_32();
+  reads.push_back(tester.size() + x.offset_of_imm());
+  tester.emit(x);
+
+  x = IGen::je_32();
+  reads.push_back(tester.size() + x.offset_of_imm());
+  tester.emit(x);
+
+  x = IGen::jne_32();
+  reads.push_back(tester.size() + x.offset_of_imm());
+  tester.emit(x);
+
+  x = IGen::jle_32();
+  reads.push_back(tester.size() + x.offset_of_imm());
+  tester.emit(x);
+
+  x = IGen::jge_32();
+  reads.push_back(tester.size() + x.offset_of_imm());
+  tester.emit(x);
+
+  x = IGen::jl_32();
+  reads.push_back(tester.size() + x.offset_of_imm());
+  tester.emit(x);
+
+  x = IGen::jg_32();
+  reads.push_back(tester.size() + x.offset_of_imm());
+  tester.emit(x);
+
+  x = IGen::jbe_32();
+  reads.push_back(tester.size() + x.offset_of_imm());
+  tester.emit(x);
+
+  x = IGen::jae_32();
+  reads.push_back(tester.size() + x.offset_of_imm());
+  tester.emit(x);
+
+  x = IGen::jb_32();
+  reads.push_back(tester.size() + x.offset_of_imm());
+  tester.emit(x);
+
+  x = IGen::ja_32();
+  reads.push_back(tester.size() + x.offset_of_imm());
+  tester.emit(x);
+
+  for (auto off : reads) {
+    EXPECT_EQ(0, tester.read<s32>(off));
+  }
+
+  EXPECT_EQ(tester.dump_to_hex_string(true),
+            "E9000000000F84000000000F85000000000F8E000000000F8D000000000F8C000000000F8F000000000F86"
+            "000000000F83000000000F82000000000F8700000000");
+}
+
+TEST(EmitterIntegerMath, null) {
+  auto instr = IGen::null();
+  EXPECT_EQ(0, instr.emit(nullptr));
+}
\ No newline at end of file
diff --git a/test/test_emitter_loads_and_store.cpp b/test/test_emitter_loads_and_store.cpp
new file mode 100644
index 0000000000..02a9261800
--- /dev/null
+++ b/test/test_emitter_loads_and_store.cpp
@@ -0,0 +1,2513 @@
+/*!
+ * @file test_emitter_loads_and_stores.cpp
+ * Tests for the emitter which are fast (checking 100's of functions)
+ */
+
+#include "gtest/gtest.h"
+#include "goalc/emitter/CodeTester.h"
+#include "goalc/emitter/IGen.h"
+#include "third-party/fmt/core.h"
+//
+using namespace emitter;
+
+TEST(EmitterLoadsAndStores, load_constant_64_and_move_gpr_gpr_64) {
+  std::vector<u64> u64_constants = {0, UINT64_MAX, INT64_MAX, 7, 12};
+
+  // test we can load a 64-bit constant into all gprs, move it to any other gpr, and return it.
+  // rsp is skipping because that's the stack pointer and would prevent us from popping gprs after
+
+  CodeTester tester;
+  tester.init_code_buffer(256);
+
+  for (auto constant : u64_constants) {
+    for (int r1 = 0; r1 < 16; r1++) {
+      if (r1 == RSP) {
+        continue;
+      }
+
+      for (int r2 = 0; r2 < 16; r2++) {
+        if (r2 == RSP) {
+          continue;
+        }
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        tester.emit(IGen::mov_gpr64_u64(r1, constant));
+        tester.emit(IGen::mov_gpr64_gpr64(r2, r1));
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, r2));
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+        EXPECT_EQ(tester.execute(), constant);
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load_constant_32_unsigned) {
+  std::vector<u64> u64_constants = {0, UINT32_MAX, INT32_MAX, 7, 12};
+
+  // test loading 32-bit constants, with all upper 32-bits zero.
+  // this uses a different opcode than 64-bit loads.
+  CodeTester tester;
+  tester.init_code_buffer(256);
+
+  for (auto constant : u64_constants) {
+    for (int r1 = 0; r1 < 16; r1++) {
+      if (r1 == RSP) {
+        continue;
+      }
+
+      tester.clear();
+      tester.emit_push_all_gprs(true);
+      tester.emit(IGen::mov_gpr64_u64(r1, UINT64_MAX));
+      tester.emit(IGen::mov_gpr64_u32(r1, constant));
+      tester.emit(IGen::mov_gpr64_gpr64(RAX, r1));
+      tester.emit_pop_all_gprs(true);
+      tester.emit_return();
+      EXPECT_EQ(tester.execute(), constant);
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load_constant_32_signed) {
+  std::vector<s32> s32_constants = {0, 1, INT32_MAX, INT32_MIN, 12, -1};
+
+  // test loading signed 32-bit constants.  for values < 0 this will sign extend.
+  CodeTester tester;
+  tester.init_code_buffer(256);
+
+  for (auto constant : s32_constants) {
+    for (int r1 = 0; r1 < 16; r1++) {
+      if (r1 == RSP) {
+        continue;
+      }
+
+      tester.clear();
+      tester.emit_push_all_gprs(true);
+      tester.emit(IGen::mov_gpr64_s32(r1, constant));
+      tester.emit(IGen::mov_gpr64_gpr64(RAX, r1));
+      tester.emit_pop_all_gprs(true);
+      tester.emit_return();
+      EXPECT_EQ(tester.execute(), constant);
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load8s_gpr64_goal_ptr_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load8s_gpr64_gpr64_plus_gpr64(RAX, RBX, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f be 04 1e");
+
+  tester.clear();
+  tester.emit(IGen::load8s_gpr64_gpr64_plus_gpr64(R12, RBX, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4c 0f be 24 1e");
+
+  tester.clear();
+  tester.emit(IGen::load8s_gpr64_gpr64_plus_gpr64(R12, R15, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4e 0f be 24 3e");
+
+  tester.clear();
+  tester.emit(IGen::load8s_gpr64_gpr64_plus_gpr64(R12, R15, R14));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4f 0f be 24 3e");
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load8s_gpr64_gpr64_plus_gpr64(k, i, j));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        u8 memory[8] = {0, 0, 0xfd, 0xfe, 0xff, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 3, 0, 0)), -2);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 2, 0, 0)), -3);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 4, 0, 0)), -1);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 5, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load8s_gpr64_gpr64_gpr64_s8) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load8s_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RBX, RSI, -3));
+
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f be 44 1e fd");
+
+  auto instr = IGen::load8s_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(s8(buff[instr.offset_of_disp()]), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load8s_gpr64_gpr64_plus_gpr64_plus_s8(k, i, j, -3));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        u8 memory[8] = {0, 0, 0xfd, 0xfe, 0xff, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 3 + 3, 0, 0)), -2);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 2 + 3, 0, 0)), -3);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 4 + 3, 0, 0)), -1);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 5 + 3, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load8s_gpr64_gpr64_gpr64_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load8s_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RBX, RSI, -3));
+
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f be 84 1e fd ff ff ff");
+
+  auto instr = IGen::load8s_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s32*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load8s_gpr64_gpr64_plus_gpr64_plus_s32(k, i, j, -3));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        u8 memory[8] = {0, 0, 0xfd, 0xfe, 0xff, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 3 + 3, 0, 0)), -2);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 2 + 3, 0, 0)), -3);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 4 + 3, 0, 0)), -1);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 5 + 3, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load8u_gpr64_goal_ptr_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load8u_gpr64_gpr64_plus_gpr64(RAX, RBX, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f b6 04 1e");
+
+  tester.clear();
+  tester.emit(IGen::load8u_gpr64_gpr64_plus_gpr64(R12, RBX, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4c 0f b6 24 1e");
+
+  tester.clear();
+  tester.emit(IGen::load8u_gpr64_gpr64_plus_gpr64(R12, R15, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4e 0f b6 24 3e");
+
+  tester.clear();
+  tester.emit(IGen::load8u_gpr64_gpr64_plus_gpr64(R12, R15, R14));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4f 0f b6 24 3e");
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load8s_gpr64_gpr64_plus_gpr64(k, i, j));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        u8 memory[8] = {0, 0, 0xfd, 0xfe, 0xff, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 3, 0, 0)), -2);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 2, 0, 0)), -3);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 4, 0, 0)), -1);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 5, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load8u_gpr64_gpr64_gpr64_s8) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load8u_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RBX, RSI, -3));
+
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f b6 44 1e fd");
+
+  auto instr = IGen::load8u_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(s8(buff[instr.offset_of_disp()]), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load8u_gpr64_gpr64_plus_gpr64_plus_s8(k, i, j, -3));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        u8 memory[8] = {0, 0, 0xfd, 0xfe, 0xff, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 3 + 3, 0, 0)), 0xfe);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 2 + 3, 0, 0)), 0xfd);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 4 + 3, 0, 0)), 0xff);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 5 + 3, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load8u_gpr64_gpr64_gpr64_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load8u_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RBX, RSI, -3));
+
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f b6 84 1e fd ff ff ff");
+
+  auto instr = IGen::load8u_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s32*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load8u_gpr64_gpr64_plus_gpr64_plus_s32(k, i, j, -3));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        u8 memory[8] = {0, 0, 0xfd, 0xfe, 0xff, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 3 + 3, 0, 0)), 0xfe);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 2 + 3, 0, 0)), 0xfd);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 4 + 3, 0, 0)), 0xff);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 5 + 3, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load16s_gpr64_goal_ptr_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load16s_gpr64_gpr64_plus_gpr64(RAX, RBX, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f bf 04 1e");
+
+  tester.clear();
+  tester.emit(IGen::load16s_gpr64_gpr64_plus_gpr64(R12, RBX, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4c 0f bf 24 1e");
+
+  tester.clear();
+  tester.emit(IGen::load16s_gpr64_gpr64_plus_gpr64(R12, R15, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4e 0f bf 24 3e");
+
+  tester.clear();
+  tester.emit(IGen::load16s_gpr64_gpr64_plus_gpr64(R12, R15, R14));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4f 0f bf 24 3e");
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load16s_gpr64_gpr64_plus_gpr64(k, i, j));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s16 memory[8] = {0, 0, -3, -2, -1, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 6, 0, 0)), -2);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 4, 0, 0)), -3);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 8, 0, 0)), -1);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 10, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load16s_gpr64_gpr64_plus_gpr64_plus_s8) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load16s_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RBX, RSI, -3));
+
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f bf 44 1e fd");
+
+  auto instr = IGen::load16s_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(s8(buff[instr.offset_of_disp()]), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load16s_gpr64_gpr64_plus_gpr64_plus_s8(k, i, j, -3));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        u16 memory[8] = {0, 0, 0xfffd, 0xfffe, 0xffff, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 6 + 3, 0, 0)), -2);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 4 + 3, 0, 0)), -3);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 8 + 3, 0, 0)), -1);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 10 + 3, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load16s_gpr64_gpr64_plus_gpr64_plus_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load16s_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RBX, RSI, -3));
+
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f bf 84 1e fd ff ff ff");
+
+  auto instr = IGen::load16s_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s32*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load16s_gpr64_gpr64_plus_gpr64_plus_s32(k, i, j, -3));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        u16 memory[8] = {0, 0, 0xfffd, 0xfffe, 0xffff, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 6 + 3, 0, 0)), -2);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 4 + 3, 0, 0)), -3);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 8 + 3, 0, 0)), -1);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 10 + 3, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load16u_gpr64_goal_ptr_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load16u_gpr64_gpr64_plus_gpr64(RAX, RBX, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f b7 04 1e");
+
+  tester.clear();
+  tester.emit(IGen::load16u_gpr64_gpr64_plus_gpr64(R12, RBX, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4c 0f b7 24 1e");
+
+  tester.clear();
+  tester.emit(IGen::load16u_gpr64_gpr64_plus_gpr64(R12, R15, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4e 0f b7 24 3e");
+
+  tester.clear();
+  tester.emit(IGen::load16u_gpr64_gpr64_plus_gpr64(R12, R15, R14));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4f 0f b7 24 3e");
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load16u_gpr64_gpr64_plus_gpr64(k, i, j));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s16 memory[8] = {0, 0, -3, -2, -1, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 6, 0, 0)), 0xfffe);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 4, 0, 0)), 0xfffd);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 8, 0, 0)), 0xffff);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 10, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load16u_gpr64_gpr64_plus_gpr64_plus_s8) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load16u_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RBX, RSI, -3));
+
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f b7 44 1e fd");
+
+  auto instr = IGen::load16u_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(s8(buff[instr.offset_of_disp()]), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load16u_gpr64_gpr64_plus_gpr64_plus_s8(k, i, j, -3));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        u16 memory[8] = {0, 0, 0xfffd, 0xfffe, 0xffff, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 6 + 3, 0, 0)), 0xfffe);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 4 + 3, 0, 0)), 0xfffd);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 8 + 3, 0, 0)), 0xffff);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 10 + 3, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load16u_gpr64_gpr64_plus_gpr64_plus_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load16u_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RBX, RSI, -3));
+
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f b7 84 1e fd ff ff ff");
+
+  auto instr = IGen::load16u_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s32*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load16u_gpr64_gpr64_plus_gpr64_plus_s32(k, i, j, -3));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        u16 memory[8] = {0, 0, 0xfffd, 0xfffe, 0xffff, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 6 + 3, 0, 0)), 0xfffe);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 4 + 3, 0, 0)), 0xfffd);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 8 + 3, 0, 0)), 0xffff);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 10 + 3, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load32s_gpr64_goal_ptr_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load32s_gpr64_gpr64_plus_gpr64(RAX, RBX, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 63 04 1e");
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load32s_gpr64_gpr64_plus_gpr64(k, i, j));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s32 memory[8] = {0, 0, -3, -2, -1, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 12, 0, 0)), -2);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 8, 0, 0)), -3);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 16, 0, 0)), -1);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 20, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load32s_gpr64_gpr64_plus_gpr64_plus_s8) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load32s_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RBX, RSI, -3));
+
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 63 44 1e fd");
+
+  auto instr = IGen::load32s_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(s8(buff[instr.offset_of_disp()]), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load32s_gpr64_gpr64_plus_gpr64_plus_s8(k, i, j, -3));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        u32 memory[8] = {0, 0, 0xfffffffd, 0xfffffffe, 0xffffffff, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 12 + 3, 0, 0)), -2);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 8 + 3, 0, 0)), -3);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 16 + 3, 0, 0)), -1);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 20 + 3, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load32s_gpr64_gpr64_plus_gpr64_plus_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load32s_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RBX, RSI, -3));
+
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 63 84 1e fd ff ff ff");
+
+  auto instr = IGen::load32s_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s32*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load32s_gpr64_gpr64_plus_gpr64_plus_s32(k, i, j, -3));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        u32 memory[8] = {0, 0, 0xfffffffd, 0xfffffffe, 0xffffffff, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 12 + 3, 0, 0)), -2);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 8 + 3, 0, 0)), -3);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 16 + 3, 0, 0)), -1);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 20 + 3, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load32u_gpr64_goal_ptr_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load32u_gpr64_gpr64_plus_gpr64(RAX, RBX, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "8b 04 1e");
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load32u_gpr64_gpr64_plus_gpr64(k, i, j));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s32 memory[8] = {0, 0, -3, -2, -1, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 12, 0, 0)), 0xfffffffe);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 8, 0, 0)), 0xfffffffd);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 16, 0, 0)), 0xffffffff);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 20, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load32u_gpr64_gpr64_plus_gpr64_plus_s8) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load32u_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RBX, RSI, -3));
+
+  EXPECT_EQ(tester.dump_to_hex_string(), "8b 44 1e fd");
+
+  auto instr = IGen::load32u_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(s8(buff[instr.offset_of_disp()]), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load32u_gpr64_gpr64_plus_gpr64_plus_s8(k, i, j, -3));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s32 memory[8] = {0, 0, -3, -2, -1, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 12 + 3, 0, 0)), 0xfffffffe);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 8 + 3, 0, 0)), 0xfffffffd);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 16 + 3, 0, 0)), 0xffffffff);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 20 + 3, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load32u_gpr64_gpr64_plus_gpr64_plus_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load32u_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RBX, RSI, -3));
+
+  EXPECT_EQ(tester.dump_to_hex_string(), "8b 84 1e fd ff ff ff");
+
+  auto instr = IGen::load32u_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s32*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load32u_gpr64_gpr64_plus_gpr64_plus_s32(k, i, j, -3));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        u32 memory[8] = {0, 0, 0xfffffffd, 0xfffffffe, 0xffffffff, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 12 + 3, 0, 0)), 0xfffffffe);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 8 + 3, 0, 0)), 0xfffffffd);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 16 + 3, 0, 0)), 0xffffffff);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 20 + 3, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load64_gpr64_goal_ptr_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load64_gpr64_gpr64_plus_gpr64(RAX, RBX, RSI));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 8b 04 1e");
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load64_gpr64_gpr64_plus_gpr64(k, i, j));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s64 memory[8] = {0, 0, -3, -2, -1, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 24, 0, 0)), -2);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 16, 0, 0)), -3);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 32, 0, 0)), -1);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 40, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load64_gpr64_gpr64_plus_gpr64_plus_s8) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load64_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RBX, RSI, -3));
+
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 8b 44 1e fd");
+
+  auto instr = IGen::load64_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(s8(buff[instr.offset_of_disp()]), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load64_gpr64_gpr64_plus_gpr64_plus_s8(k, i, j, -3));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s64 memory[8] = {0, 0, -3, -2, -1, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 24 + 3, 0, 0)), -2);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 16 + 3, 0, 0)), -3);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 32 + 3, 0, 0)), -1);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 40 + 3, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load64_gpr64_gpr64_plus_gpr64_plus_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::load64_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RBX, RSI, -3));
+
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 8b 84 1e fd ff ff ff");
+
+  auto instr = IGen::load64_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s32*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // fill k with junk
+        if (k != i && k != j) {
+          tester.emit(IGen::mov_gpr64_u64(k, (iter & 1) ? 0 : UINT64_MAX));
+        }
+
+        // load into k
+        tester.emit(IGen::load64_gpr64_gpr64_plus_gpr64_plus_s32(k, i, j, -3));
+
+        // move k to return register
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s64 memory[8] = {0, 0, -3, -2, -1, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(s64(tester.execute((u64)memory, 24 + 3, 0, 0)), -2);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 16 + 3, 0, 0)), -3);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 32 + 3, 0, 0)), -1);
+        EXPECT_EQ(s64(tester.execute((u64)memory, 40 + 3, 0, 0)), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, store8_gpr64_gpr64_plus_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::store8_gpr64_gpr64_plus_gpr64(RAX, RCX, RDX));
+  EXPECT_EQ(tester.dump_to_hex_string(), "88 14 01");
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP || k == j || k == i) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+        tester.emit(IGen::pop_gpr64(k));  // k will have the value to store.
+
+        // store!
+        tester.emit(IGen::store8_gpr64_gpr64_plus_gpr64(i, j, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s8 memory[8] = {0, 0, 3, -2, 1, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 3, 0xffffffffffffff07, 0);
+        EXPECT_EQ(memory[2], 3);
+        EXPECT_EQ(memory[3], 7);
+        EXPECT_EQ(memory[4], 1);
+
+        if (memory[3] != 7) {
+          fmt::print("test {}, {}, {}\n", tester.reg_name(i), tester.reg_name(j),
+                     tester.reg_name(k));
+          printf("%s\n", tester.dump_to_hex_string().c_str());
+        }
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, store8_gpr64_gpr64_plus_gpr64_plus_s8) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::store8_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RCX, RDX, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "88 54 01 0c");
+
+  auto instr = IGen::store8_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RCX, RDX, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s8*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP || k == j || k == i) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+        tester.emit(IGen::pop_gpr64(k));  // k will have the value to store.
+
+        // store
+        tester.emit(IGen::store8_gpr64_gpr64_plus_gpr64_plus_s8(i, j, k, -3));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s8 memory[8] = {0, 0, 3, -2, 1, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 6, 0xffffffffffffff07, 0);
+        EXPECT_EQ(memory[2], 3);
+        EXPECT_EQ(memory[3], 7);
+        EXPECT_EQ(memory[4], 1);
+
+        if (memory[3] != 7) {
+          fmt::print("test {}, {}, {}\n", tester.reg_name(i), tester.reg_name(j),
+                     tester.reg_name(k));
+          printf("%s\n", tester.dump_to_hex_string().c_str());
+        }
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, store8_gpr64_gpr64_plus_gpr64_plus_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::store8_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RCX, RDX, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "88 94 01 0c 00 00 00");
+
+  auto instr = IGen::store8_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RCX, RDX, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s32*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP || k == j || k == i) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+        tester.emit(IGen::pop_gpr64(k));  // k will have the value to store.
+
+        // store
+        tester.emit(IGen::store8_gpr64_gpr64_plus_gpr64_plus_s32(i, j, k, -3));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s8 memory[8] = {0, 0, 3, -2, 1, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 6, 0xffffffffffffff07, 0);
+        EXPECT_EQ(memory[2], 3);
+        EXPECT_EQ(memory[3], 7);
+        EXPECT_EQ(memory[4], 1);
+
+        if (memory[3] != 7) {
+          fmt::print("test {}, {}, {}\n", tester.reg_name(i), tester.reg_name(j),
+                     tester.reg_name(k));
+          printf("%s\n", tester.dump_to_hex_string().c_str());
+        }
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, store16_gpr64_gpr64_plus_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::store16_gpr64_gpr64_plus_gpr64(RCX, RAX, R8));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 44 89 04 08");
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP || k == j || k == i) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+        tester.emit(IGen::pop_gpr64(k));  // k will have the value to store.
+
+        // store!
+        tester.emit(IGen::store16_gpr64_gpr64_plus_gpr64(i, j, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s16 memory[8] = {0, 0, 3, -2, 1, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 6, 0xffffffffffffff07, 0);
+        EXPECT_EQ(memory[2], 3);
+        EXPECT_EQ(memory[3], s16(0xff07));
+        EXPECT_EQ(memory[4], 1);
+
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, store16_gpr64_gpr64_plus_gpr64_plus_s8) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::store16_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RCX, R8, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 44 89 44 01 0c");
+
+  auto instr = IGen::store16_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RCX, RDX, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s8*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP || k == j || k == i) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+        tester.emit(IGen::pop_gpr64(k));  // k will have the value to store.
+
+        // store
+        tester.emit(IGen::store16_gpr64_gpr64_plus_gpr64_plus_s8(i, j, k, -3));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s16 memory[8] = {0, 0, 3, -2, 1, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 6 + 3, 0xffffffffffffff07, 0);
+        EXPECT_EQ(memory[2], 3);
+        EXPECT_EQ(memory[3], s16(0xff07));
+        EXPECT_EQ(memory[4], 1);
+
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, store16_gpr64_gpr64_plus_gpr64_plus_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::store16_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RCX, R8, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 44 89 84 01 0c 00 00 00");
+
+  auto instr = IGen::store16_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RCX, RDX, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s8*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP || k == j || k == i) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+        tester.emit(IGen::pop_gpr64(k));  // k will have the value to store.
+
+        // store
+        tester.emit(IGen::store16_gpr64_gpr64_plus_gpr64_plus_s32(i, j, k, -3));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s16 memory[8] = {0, 0, 3, -2, 1, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 6 + 3, 0xffffffffffffff07, 0);
+        EXPECT_EQ(memory[2], 3);
+        EXPECT_EQ(memory[3], s16(0xff07));
+        EXPECT_EQ(memory[4], 1);
+
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, store32_gpr64_gpr64_plus_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::store32_gpr64_gpr64_plus_gpr64(RCX, RAX, R8));
+  EXPECT_EQ(tester.dump_to_hex_string(), "44 89 04 08");
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP || k == j || k == i) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+        tester.emit(IGen::pop_gpr64(k));  // k will have the value to store.
+
+        // store!
+        tester.emit(IGen::store32_gpr64_gpr64_plus_gpr64(i, j, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s32 memory[8] = {0, 0, 3, -2, 1, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 12, 0xffffffff12341234, 0);
+        EXPECT_EQ(memory[2], 3);
+        EXPECT_EQ(memory[3], 0x12341234);
+        EXPECT_EQ(memory[4], 1);
+
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, store32_gpr64_gpr64_plus_gpr64_plus_s8) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::store32_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RCX, R8, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "44 89 44 01 0c");
+
+  auto instr = IGen::store32_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RCX, RDX, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s8*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP || k == j || k == i) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+        tester.emit(IGen::pop_gpr64(k));  // k will have the value to store.
+
+        // store
+        tester.emit(IGen::store32_gpr64_gpr64_plus_gpr64_plus_s8(i, j, k, -3));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s32 memory[8] = {0, 0, 3, -2, 1, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 12 + 3, 0xffffffffffffff07, 0);
+        EXPECT_EQ(memory[2], 3);
+        EXPECT_EQ(memory[3], s32(0xffffff07));
+        EXPECT_EQ(memory[4], 1);
+
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, store32_gpr64_gpr64_plus_gpr64_plus_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::store32_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RCX, R8, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "44 89 84 01 0c 00 00 00");
+
+  auto instr = IGen::store32_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RCX, RDX, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s8*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP || k == j || k == i) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+        tester.emit(IGen::pop_gpr64(k));  // k will have the value to store.
+
+        // store
+        tester.emit(IGen::store32_gpr64_gpr64_plus_gpr64_plus_s32(i, j, k, -3));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s32 memory[8] = {0, 0, 3, -2, 1, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 12 + 3, 0xffffffffffffff07, 0);
+        EXPECT_EQ(memory[2], 3);
+        EXPECT_EQ(memory[3], s32(0xffffff07));
+        EXPECT_EQ(memory[4], 1);
+
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, store64_gpr64_gpr64_plus_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::store64_gpr64_gpr64_plus_gpr64(RCX, RAX, R8));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4c 89 04 08");
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP || k == j || k == i) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+        tester.emit(IGen::pop_gpr64(k));  // k will have the value to store.
+
+        // store!
+        tester.emit(IGen::store64_gpr64_gpr64_plus_gpr64(i, j, k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s64 memory[8] = {0, 0, 3, -2, 1, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 24, 0xffffffff12341234, 0);
+        EXPECT_EQ(memory[2], 3);
+        EXPECT_EQ(memory[3], 0xffffffff12341234);
+        EXPECT_EQ(memory[4], 1);
+
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, store64_gpr64_gpr64_plus_gpr64_plus_s8) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::store64_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RCX, R8, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4c 89 44 01 0c");
+
+  auto instr = IGen::store64_gpr64_gpr64_plus_gpr64_plus_s8(RAX, RCX, RDX, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s8*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP || k == j || k == i) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+        tester.emit(IGen::pop_gpr64(k));  // k will have the value to store.
+
+        // store
+        tester.emit(IGen::store64_gpr64_gpr64_plus_gpr64_plus_s8(i, j, k, -3));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s64 memory[8] = {0, 0, 3, -2, 1, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 24 + 3, 0xffffffffffffff07, 0);
+        EXPECT_EQ(memory[2], 3);
+        EXPECT_EQ(memory[3], s64(0xffffffffffffff07));
+        EXPECT_EQ(memory[4], 1);
+
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, store64_gpr64_gpr64_plus_gpr64_plus_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  tester.clear();
+  tester.emit(IGen::store64_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RCX, R8, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "4c 89 84 01 0c 00 00 00");
+
+  auto instr = IGen::store64_gpr64_gpr64_plus_gpr64_plus_s32(RAX, RCX, RDX, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s8*)(buff + instr.offset_of_disp()), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        if (k == RSP || k == j || k == i) {
+          continue;
+        }
+
+        tester.clear();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+        tester.emit(IGen::pop_gpr64(k));  // k will have the value to store.
+
+        // store
+        tester.emit(IGen::store64_gpr64_gpr64_plus_gpr64_plus_s32(i, j, k, -3));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_return();
+
+        // prepare the memory:
+        s64 memory[8] = {0, 0, 3, -2, 1, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 24 + 3, 0xffffffffffffff07, 0);
+        EXPECT_EQ(memory[2], 3);
+        EXPECT_EQ(memory[3], s64(0xffffffffffffff07));
+        EXPECT_EQ(memory[4], 1);
+
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterLoadsAndStores, load64_rip) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  tester.emit(IGen::load64_rip_s32(RAX, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 8b 05 0c 00 00 00");
+
+  tester.clear();
+  for (int i = 0; i < 16; i++) {
+    tester.emit(IGen::load64_rip_s32(i, 12));
+  }
+
+  EXPECT_EQ(tester.dump_to_hex_string(true),
+            "488B050C000000488B0D0C000000488B150C000000488B1D0C000000488B250C000000488B2D0C00000048"
+            "8B350C000000488B3D0C0000004C8B050C0000004C8B0D0C0000004C8B150C0000004C8B1D0C0000004C8B"
+            "250C0000004C8B2D0C0000004C8B350C0000004C8B3D0C000000");
+}
+
+TEST(EmitterLoadsAndStores, load32s_rip) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  tester.emit(IGen::load32s_rip_s32(RAX, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 63 05 0c 00 00 00");
+
+  tester.clear();
+  for (int i = 0; i < 16; i++) {
+    tester.emit(IGen::load32s_rip_s32(i, 12));
+  }
+
+  EXPECT_EQ(tester.dump_to_hex_string(true),
+            "4863050C00000048630D0C0000004863150C00000048631D0C0000004863250C00000048632D0C00000048"
+            "63350C00000048633D0C0000004C63050C0000004C630D0C0000004C63150C0000004C631D0C0000004C63"
+            "250C0000004C632D0C0000004C63350C0000004C633D0C000000");
+}
+
+TEST(EmitterLoadsAndStores, load32u_rip) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  tester.emit(IGen::load32u_rip_s32(RAX, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "8b 05 0c 00 00 00");
+
+  tester.clear();
+  for (int i = 0; i < 16; i++) {
+    tester.emit(IGen::load32u_rip_s32(i, 12));
+  }
+
+  EXPECT_EQ(tester.dump_to_hex_string(true),
+            "8B050C0000008B0D0C0000008B150C0000008B1D0C0000008B250C0000008B2D0C0000008B350C0000008B"
+            "3D0C000000448B050C000000448B0D0C000000448B150C000000448B1D0C000000448B250C000000448B2D"
+            "0C000000448B350C000000448B3D0C000000");
+}
+
+TEST(EmitterLoadsAndStores, load16u_rip) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  tester.emit(IGen::load16u_rip_s32(RAX, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f b7 05 0c 00 00 00");
+
+  tester.clear();
+  for (int i = 0; i < 16; i++) {
+    tester.emit(IGen::load16u_rip_s32(i, 12));
+  }
+
+  EXPECT_EQ(tester.dump_to_hex_string(true),
+            "480FB7050C000000480FB70D0C000000480FB7150C000000480FB71D0C000000480FB7250C000000480FB7"
+            "2D0C000000480FB7350C000000480FB73D0C0000004C0FB7050C0000004C0FB70D0C0000004C0FB7150C00"
+            "00004C0FB71D0C0000004C0FB7250C0000004C0FB72D0C0000004C0FB7350C0000004C0FB73D0C000000");
+}
+
+TEST(EmitterLoadsAndStores, load16s_rip) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  tester.emit(IGen::load16s_rip_s32(RAX, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f bf 05 0c 00 00 00");
+
+  tester.clear();
+  for (int i = 0; i < 16; i++) {
+    tester.emit(IGen::load16s_rip_s32(i, 12));
+  }
+
+  EXPECT_EQ(tester.dump_to_hex_string(true),
+            "480FBF050C000000480FBF0D0C000000480FBF150C000000480FBF1D0C000000480FBF250C000000480FBF"
+            "2D0C000000480FBF350C000000480FBF3D0C0000004C0FBF050C0000004C0FBF0D0C0000004C0FBF150C00"
+            "00004C0FBF1D0C0000004C0FBF250C0000004C0FBF2D0C0000004C0FBF350C0000004C0FBF3D0C000000");
+}
+
+TEST(EmitterLoadsAndStores, load8s_rip) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  tester.emit(IGen::load8s_rip_s32(RAX, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f be 05 0c 00 00 00");
+
+  tester.clear();
+  for (int i = 0; i < 16; i++) {
+    tester.emit(IGen::load8s_rip_s32(i, 12));
+  }
+
+  EXPECT_EQ(tester.dump_to_hex_string(true),
+            "480FBE050C000000480FBE0D0C000000480FBE150C000000480FBE1D0C000000480FBE250C000000480FBE"
+            "2D0C000000480FBE350C000000480FBE3D0C0000004C0FBE050C0000004C0FBE0D0C0000004C0FBE150C00"
+            "00004C0FBE1D0C0000004C0FBE250C0000004C0FBE2D0C0000004C0FBE350C0000004C0FBE3D0C000000");
+}
+
+TEST(EmitterLoadsAndStores, load8u_rip) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  tester.emit(IGen::load8u_rip_s32(RAX, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 0f b6 05 0c 00 00 00");
+
+  tester.clear();
+  for (int i = 0; i < 16; i++) {
+    tester.emit(IGen::load8u_rip_s32(i, 12));
+  }
+
+  EXPECT_EQ(tester.dump_to_hex_string(true),
+            "480FB6050C000000480FB60D0C000000480FB6150C000000480FB61D0C000000480FB6250C000000480FB6"
+            "2D0C000000480FB6350C000000480FB63D0C0000004C0FB6050C0000004C0FB60D0C0000004C0FB6150C00"
+            "00004C0FB61D0C0000004C0FB6250C0000004C0FB62D0C0000004C0FB6350C0000004C0FB63D0C000000");
+}
+
+TEST(EmitterLoadsAndStores, store64_rip_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  tester.emit(IGen::store64_rip_s32(RAX, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "48 89 05 0c 00 00 00");
+
+  tester.clear();
+  for (int i = 0; i < 16; i++) {
+    tester.emit(IGen::store64_rip_s32(i, 12));
+  }
+
+  EXPECT_EQ(tester.dump_to_hex_string(true),
+            "4889050C00000048890D0C0000004889150C00000048891D0C0000004889250C00000048892D0C00000048"
+            "89350C00000048893D0C0000004C89050C0000004C890D0C0000004C89150C0000004C891D0C0000004C89"
+            "250C0000004C892D0C0000004C89350C0000004C893D0C000000");
+}
+
+TEST(EmitterLoadsAndStores, store32_rip_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  tester.emit(IGen::store32_rip_s32(RAX, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "89 05 0c 00 00 00");
+
+  tester.clear();
+  for (int i = 0; i < 16; i++) {
+    tester.emit(IGen::store32_rip_s32(i, 12));
+  }
+
+  EXPECT_EQ(tester.dump_to_hex_string(true),
+            "89050C000000890D0C00000089150C000000891D0C00000089250C000000892D0C00000089350C00000089"
+            "3D0C0000004489050C00000044890D0C0000004489150C00000044891D0C0000004489250C00000044892D"
+            "0C0000004489350C00000044893D0C000000");
+}
+
+TEST(EmitterLoadsAndStores, store16_rip_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  tester.emit(IGen::store16_rip_s32(RAX, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "66 89 05 0c 00 00 00");
+
+  tester.clear();
+  for (int i = 0; i < 16; i++) {
+    tester.emit(IGen::store16_rip_s32(i, 12));
+  }
+
+  EXPECT_EQ(tester.dump_to_hex_string(true),
+            "6689050C00000066890D0C0000006689150C00000066891D0C0000006689250C00000066892D0C00000066"
+            "89350C00000066893D0C000000664489050C0000006644890D0C000000664489150C0000006644891D0C00"
+            "0000664489250C0000006644892D0C000000664489350C0000006644893D0C000000");
+}
+
+TEST(EmitterLoadsAndStores, store8_rip_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(256);
+  tester.emit(IGen::store8_rip_s32(RAX, 12));
+  EXPECT_EQ(tester.dump_to_hex_string(), "88 05 0c 00 00 00");
+
+  tester.clear();
+  for (int i = 0; i < 16; i++) {
+    tester.emit(IGen::store8_rip_s32(i, 12));
+  }
+
+  EXPECT_EQ(tester.dump_to_hex_string(true),
+            "88050C000000880D0C00000088150C000000881D0C0000004088250C00000040882D0C0000004088350C00"
+            "000040883D0C0000004488050C00000044880D0C0000004488150C00000044881D0C0000004488250C0000"
+            "0044882D0C0000004488350C00000044883D0C000000");
+}
+
+TEST(EmitterLoadsAndStores, static_addr) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    tester.clear();
+    tester.emit_push_all_gprs(true);
+    tester.emit(IGen::mov_gpr64_u64(i, 12345));  // load test reg with junk
+    int start_of_lea = tester.size();
+    auto lea_instr = IGen::static_addr(i, INT32_MAX);
+    tester.emit(lea_instr);
+    // patch instruction to lea the start of this code + 1.
+    tester.write<s32>(-start_of_lea - lea_instr.length() + 1,
+                      start_of_lea + lea_instr.offset_of_disp());
+    tester.emit(IGen::mov_gpr64_gpr64(RAX, i));
+    tester.emit_pop_all_gprs(true);
+    tester.emit_return();
+
+    auto result = tester.execute();
+    EXPECT_EQ(result, (u64)(tester.data()) + 1);
+  }
+}
\ No newline at end of file
diff --git a/test/test_emitter_slow.cpp b/test/test_emitter_slow.cpp
new file mode 100644
index 0000000000..ebe298745d
--- /dev/null
+++ b/test/test_emitter_slow.cpp
@@ -0,0 +1,53 @@
+/*!
+ * @file test_emitter_slow.cpp
+ * Tests for the emitter which take over 1 second. (Checking 10,000's of functions).
+ *
+ * It may make sense to exclude these tests when developing to save time.
+ */
+
+#include "gtest/gtest.h"
+#include "goalc/emitter/CodeTester.h"
+#include "goalc/emitter/IGen.h"
+//
+using namespace emitter;
+
+TEST(EmitterSlow, xmm32_move) {
+  std::vector<u32> u32_constants = {0, INT32_MAX, UINT32_MAX, 17};
+
+  // test moving between xmms (32-bit) and gprs.
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  for (auto constant : u32_constants) {
+    for (int r1 = 0; r1 < 16; r1++) {
+      if (r1 == RSP) {
+        continue;
+      }
+      for (int r2 = 0; r2 < 16; r2++) {
+        if (r2 == RSP) {
+          continue;
+        }
+        for (int r3 = 0; r3 < 16; r3++) {
+          for (int r4 = 0; r4 < 16; r4++) {
+            tester.clear();
+            tester.emit_push_all_xmms();
+            tester.emit_push_all_gprs(true);
+            // move constant to gpr
+            tester.emit(IGen::mov_gpr64_u32(r1, constant));
+            // move gpr to xmm
+            tester.emit(IGen::movd_xmm32_gpr32(XMM0 + r3, r1));
+            // move xmm to xmm
+            tester.emit(IGen::mov_xmm32_xmm32(XMM0 + r4, XMM0 + r3));
+            // move xmm to gpr
+            tester.emit(IGen::movd_gpr32_xmm32(r2, XMM0 + r4));
+            // return!
+            tester.emit(IGen::mov_gpr64_gpr64(RAX, r2));
+            tester.emit_pop_all_gprs(true);
+            tester.emit_pop_all_xmms();
+            tester.emit_return();
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/test/test_emitter_xmm32.cpp b/test/test_emitter_xmm32.cpp
new file mode 100644
index 0000000000..97b1651214
--- /dev/null
+++ b/test/test_emitter_xmm32.cpp
@@ -0,0 +1,659 @@
+#include "gtest/gtest.h"
+#include "goalc/emitter/CodeTester.h"
+#include "goalc/emitter/IGen.h"
+#include "third-party/fmt/core.h"
+
+using namespace emitter;
+
+TEST(EmitterXmm32, load32_xmm32_gpr64_plus_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+  tester.emit(IGen::load32_xmm32_gpr64_plus_gpr64(XMM3, RAX, RBX));
+  EXPECT_EQ(tester.dump_to_hex_string(), "f3 0f 10 1c 03");
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+      for (int k = 0; k < 16; k++) {
+        tester.clear();
+        tester.emit_push_all_xmms();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // fill k with junk
+        tester.emit(IGen::mov_gpr64_u64(i, (iter & 1) ? 0 : UINT64_MAX));
+        tester.emit(IGen::movd_xmm32_gpr32(XMM0 + k, i));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // load into k
+        tester.emit(IGen::load32_xmm32_gpr64_plus_gpr64(XMM0 + k, i, j));
+        // move to return
+        tester.emit(IGen::movd_gpr32_xmm32(RAX, XMM0 + k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_pop_all_xmms();
+        tester.emit_return();
+
+        // prepare the memory:
+        float memory[8] = {0, 0, 1.23f, 3.45f, 5.67f, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(tester.execute_ret<float>((u64)memory, 3 * sizeof(float), 0, 0), 3.45f);
+        EXPECT_EQ(tester.execute_ret<float>((u64)memory, 2 * sizeof(float), 0, 0), 1.23f);
+        EXPECT_EQ(tester.execute_ret<float>((u64)memory, 4 * sizeof(float), 0, 0), 5.67f);
+        EXPECT_EQ(tester.execute_ret<float>((u64)memory, 5 * sizeof(float), 0, 0), 0);
+
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterXmm32, load32_xmm32_gpr64_plus_gpr64_plus_s8) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+  tester.emit(IGen::load32_xmm32_gpr64_plus_gpr64_plus_s8(XMM3, RAX, RBX, -1));
+  EXPECT_EQ(tester.dump_to_hex_string(), "f3 0f 10 5c 03 ff");
+
+  auto instr = IGen::load32_xmm32_gpr64_plus_gpr64_plus_s8(XMM3, RBX, RSI, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(s8(buff[instr.offset_of_disp()]), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+      for (int k = 0; k < 16; k++) {
+        tester.clear();
+        tester.emit_push_all_xmms();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // fill k with junk
+        tester.emit(IGen::mov_gpr64_u64(i, (iter & 1) ? 0 : UINT64_MAX));
+        tester.emit(IGen::movd_xmm32_gpr32(XMM0 + k, i));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        // load into k
+        tester.emit(IGen::load32_xmm32_gpr64_plus_gpr64_plus_s8(XMM0 + k, i, j, -3));
+        // move to return
+        tester.emit(IGen::movd_gpr32_xmm32(RAX, XMM0 + k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_pop_all_xmms();
+        tester.emit_return();
+
+        // prepare the memory:
+        float memory[8] = {0, 0, 1.23f, 3.45f, 5.67f, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(tester.execute_ret<float>((u64)memory, 3 * sizeof(float) + 3, 0, 0), 3.45f);
+        EXPECT_EQ(tester.execute_ret<float>((u64)memory, 2 * sizeof(float) + 3, 0, 0), 1.23f);
+        EXPECT_EQ(tester.execute_ret<float>((u64)memory, 4 * sizeof(float) + 3, 0, 0), 5.67f);
+        EXPECT_EQ(tester.execute_ret<float>((u64)memory, 5 * sizeof(float) + 3, 0, 0), 0);
+
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterXmm32, load32_xmm32_gpr64_plus_gpr64_plus_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+  tester.emit(IGen::load32_xmm32_gpr64_plus_gpr64_plus_s32(XMM3, RAX, RBX, -1));
+  EXPECT_EQ(tester.dump_to_hex_string(), "f3 0f 10 9c 03 ff ff ff ff");
+
+  auto instr = IGen::load32_xmm32_gpr64_plus_gpr64_plus_s32(XMM3, RBX, RSI, -1234);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s32*)(buff + instr.offset_of_disp()), -1234);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+      for (int k = 0; k < 16; k++) {
+        tester.clear();
+        tester.emit_push_all_xmms();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));
+
+        // fill k with junk
+        tester.emit(IGen::mov_gpr64_u64(i, (iter & 1) ? 0 : UINT64_MAX));
+        tester.emit(IGen::movd_xmm32_gpr32(XMM0 + k, i));
+
+        // pop args into appropriate register
+        tester.emit(IGen::pop_gpr64(i));  // i will have offset 0
+        tester.emit(IGen::pop_gpr64(j));  // j will have offset 1
+
+        s64 offset = (iter & 1) ? INT32_MAX : INT32_MIN;
+
+        // load into k
+        tester.emit(IGen::load32_xmm32_gpr64_plus_gpr64_plus_s32(XMM0 + k, i, j, offset));
+        // move to return
+        tester.emit(IGen::movd_gpr32_xmm32(RAX, XMM0 + k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_pop_all_xmms();
+        tester.emit_return();
+
+        // prepare the memory:
+        float memory[8] = {0, 0, 1.23f, 3.45f, 5.67f, 0, 0, 0};
+
+        // run!
+        EXPECT_EQ(tester.execute_ret<float>((u64)memory, 3 * sizeof(float) - offset, 0, 0), 3.45f);
+        EXPECT_EQ(tester.execute_ret<float>((u64)memory, 2 * sizeof(float) - offset, 0, 0), 1.23f);
+        EXPECT_EQ(tester.execute_ret<float>((u64)memory, 4 * sizeof(float) - offset, 0, 0), 5.67f);
+        EXPECT_EQ(tester.execute_ret<float>((u64)memory, 5 * sizeof(float) - offset, 0, 0), 0);
+        iter++;
+      }
+    }
+  }
+}
+
+namespace {
+template <typename T>
+float as_float(T x) {
+  float result;
+  memcpy(&result, &x, sizeof(float));
+  return result;
+}
+
+u32 as_u32(float x) {
+  u32 result;
+  memcpy(&result, &x, 4);
+  return result;
+}
+}  // namespace
+
+TEST(EmitterXmm32, store32_xmm32_gpr64_plus_gpr64) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+  tester.emit(IGen::store32_xmm32_gpr64_plus_gpr64(RAX, RBX, XMM7));
+  EXPECT_EQ(tester.dump_to_hex_string(), "f3 0f 11 3c 03");
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+
+      for (int k = 0; k < 16; k++) {
+        tester.clear();
+        tester.emit_push_all_xmms();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));  // addr2
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));  // addr1
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));  // value
+
+        // pop value into addr1 GPR
+        tester.emit(IGen::pop_gpr64(i));
+        // move to XMM
+        tester.emit(IGen::movd_xmm32_gpr32(XMM0 + k, i));
+
+        // pop addrs
+        tester.emit(IGen::pop_gpr64(i));
+        tester.emit(IGen::pop_gpr64(j));
+
+        // store
+        tester.emit(IGen::store32_xmm32_gpr64_plus_gpr64(i, j, XMM0 + k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_pop_all_xmms();
+        tester.emit_return();
+
+        // prepare the memory:
+        float memory[8] = {0, 0, 1.23f, 3.45f, 5.67f, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 12, as_u32(1.234f), 0);
+        EXPECT_EQ(memory[2], 1.23f);
+        EXPECT_EQ(memory[3], 1.234f);
+        EXPECT_EQ(memory[4], 5.67f);
+
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterXmm32, store32_xmm32_gpr64_plus_gpr64_plus_s8) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+  tester.emit(IGen::store32_xmm32_gpr64_plus_gpr64_plus_s8(RAX, RBX, XMM3, -1));
+  EXPECT_EQ(tester.dump_to_hex_string(), "f3 0f 11 5c 03 ff");
+
+  auto instr = IGen::store32_xmm32_gpr64_plus_gpr64_plus_s8(RBX, RSI, XMM3, -3);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(s8(buff[instr.offset_of_disp()]), -3);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+      for (int k = 0; k < 16; k++) {
+        tester.clear();
+        tester.emit_push_all_xmms();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));  // addr2
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));  // addr1
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));  // value
+
+        // pop value into addr1 GPR
+        tester.emit(IGen::pop_gpr64(i));
+        // move to XMM
+        tester.emit(IGen::movd_xmm32_gpr32(XMM0 + k, i));
+
+        // pop addrs
+        tester.emit(IGen::pop_gpr64(i));
+        tester.emit(IGen::pop_gpr64(j));
+
+        s64 offset = (iter & 1) ? INT8_MAX : INT8_MIN;
+
+        // load into k
+        tester.emit(IGen::store32_xmm32_gpr64_plus_gpr64_plus_s8(i, j, XMM0 + k, offset));
+
+        // move to return
+        tester.emit(IGen::movd_gpr32_xmm32(RAX, XMM0 + k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_pop_all_xmms();
+        tester.emit_return();
+
+        // prepare the memory:
+        float memory[8] = {0, 0, 1.23f, 3.45f, 5.67f, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 12 - offset, as_u32(1.234f), 0);
+        EXPECT_EQ(memory[2], 1.23f);
+        EXPECT_EQ(memory[3], 1.234f);
+        EXPECT_EQ(memory[4], 5.67f);
+
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterXmm32, store32_xmm32_gpr64_plus_gpr64_plus_s32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+  tester.emit(IGen::store32_xmm32_gpr64_plus_gpr64_plus_s32(RAX, RBX, XMM3, -1));
+  EXPECT_EQ(tester.dump_to_hex_string(), "f3 0f 11 9c 03 ff ff ff ff");
+
+  auto instr = IGen::store32_xmm32_gpr64_plus_gpr64_plus_s32(RBX, RSI, XMM3, -1234);
+  u8 buff[256];
+  instr.emit(buff);
+  EXPECT_EQ(*(s32*)(buff + instr.offset_of_disp()), -1234);
+
+  int iter = 0;
+  for (int i = 0; i < 16; i++) {
+    if (i == RSP) {
+      continue;
+    }
+    for (int j = 0; j < 16; j++) {
+      if (j == RSP || j == i) {
+        continue;
+      }
+      for (int k = 0; k < 16; k++) {
+        tester.clear();
+        tester.emit_push_all_xmms();
+        tester.emit_push_all_gprs(true);
+        // push args to the stack
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(1)));  // addr2
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(0)));  // addr1
+        tester.emit(IGen::push_gpr64(tester.get_c_abi_arg_reg(2)));  // value
+
+        // pop value into addr1 GPR
+        tester.emit(IGen::pop_gpr64(i));
+        // move to XMM
+        tester.emit(IGen::movd_xmm32_gpr32(XMM0 + k, i));
+
+        // pop addrs
+        tester.emit(IGen::pop_gpr64(i));
+        tester.emit(IGen::pop_gpr64(j));
+
+        s64 offset = (iter & 1) ? INT32_MAX : INT32_MIN;
+
+        // load into k
+        tester.emit(IGen::store32_xmm32_gpr64_plus_gpr64_plus_s32(i, j, XMM0 + k, offset));
+
+        // move to return
+        tester.emit(IGen::movd_gpr32_xmm32(RAX, XMM0 + k));
+
+        // return!
+        tester.emit_pop_all_gprs(true);
+        tester.emit_pop_all_xmms();
+        tester.emit_return();
+
+        // prepare the memory:
+        float memory[8] = {0, 0, 1.23f, 3.45f, 5.67f, 0, 0, 0};
+
+        // run!
+        tester.execute((u64)memory, 12 - offset, as_u32(1.234f), 0);
+        EXPECT_EQ(memory[2], 1.23f);
+        EXPECT_EQ(memory[3], 1.234f);
+        EXPECT_EQ(memory[4], 5.67f);
+
+        iter++;
+      }
+    }
+  }
+}
+
+TEST(EmitterXmm32, static_load_xmm32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+  for (int i = 0; i < 16; i++) {
+    tester.clear();
+    tester.emit_push_all_xmms();
+    tester.emit_push_all_gprs(true);
+
+    auto loc_of_load = tester.size();
+    auto load_instr = IGen::static_load_xmm32(XMM0 + i, INT32_MAX);
+
+    tester.emit(load_instr);
+    tester.emit(IGen::movd_gpr32_xmm32(RAX, XMM0 + i));
+    tester.emit_pop_all_gprs(true);
+    tester.emit_pop_all_xmms();
+    tester.emit_return();
+    auto loc_of_float = tester.emit_data(float(1.2345f));
+
+    // patch offset
+    tester.write<s32>(loc_of_float - loc_of_load - load_instr.length(),
+                      loc_of_load + load_instr.offset_of_disp());
+
+    auto result = tester.execute_ret<float>(0, 0, 0, 0);
+    EXPECT_EQ(result, 1.2345f);
+  }
+}
+
+TEST(EmitterXmm32, static_store_xmm32) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+  for (int i = 0; i < 16; i++) {
+    tester.clear();
+    tester.emit_push_all_xmms();
+    tester.emit_push_all_gprs(true);
+    tester.emit(IGen::movd_xmm32_gpr32(XMM0 + i, tester.get_c_abi_arg_reg(0)));
+
+    auto loc_of_store = tester.size();
+    auto store_instr = IGen::static_store_xmm32(XMM0 + i, INT32_MAX);
+
+    tester.emit(store_instr);
+    tester.emit_pop_all_gprs(true);
+    tester.emit_pop_all_xmms();
+    tester.emit_return();
+    auto loc_of_float = tester.emit_data(float(1.2345f));
+
+    tester.write<s32>(loc_of_float - loc_of_store - store_instr.length(),
+                      loc_of_store + store_instr.offset_of_disp());
+    tester.execute(as_u32(-44.567f), 0, 0, 0);
+    EXPECT_EQ(-44.567f, tester.read<float>(loc_of_float));
+  }
+}
+
+TEST(EmitterXmm32, ucomiss) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+  tester.emit(IGen::cmp_flt_flt(XMM13, XMM14));
+  EXPECT_EQ("45 0f 2e ee", tester.dump_to_hex_string());
+}
+
+TEST(EmitterXmm32, mul) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  std::vector<float> vals = {0.f, 1.f, 0.2f, -1.f, 1235423.2f, -3457343.3f, 7.545f};
+
+  for (auto f : vals) {
+    for (auto g : vals) {
+      for (int i = 0; i < 16; i++) {
+        for (int j = 0; j < 16; j++) {
+          if (i == j) {
+            continue;
+          }
+          auto expected = f * g;
+          tester.clear();
+          tester.emit_push_all_xmms();
+          tester.emit_push_all_gprs(true);
+          u64 val = 0;
+          memcpy(&val, &f, sizeof(float));
+          tester.emit(IGen::mov_gpr64_u64(RAX, val));
+          tester.emit(IGen::movd_xmm32_gpr32(XMM0 + i, RAX));
+          memcpy(&val, &g, sizeof(float));
+          tester.emit(IGen::mov_gpr64_u64(RAX, val));
+          tester.emit(IGen::movd_xmm32_gpr32(XMM0 + j, RAX));
+          tester.emit(IGen::mulss_xmm_xmm(XMM0 + j, XMM0 + i));
+          tester.emit(IGen::movd_gpr32_xmm32(RAX, XMM0 + j));
+          tester.emit_pop_all_gprs(true);
+          tester.emit_pop_all_xmms();
+          tester.emit_return();
+          auto result = tester.execute_ret<float>(0, 0, 0, 0);
+          EXPECT_EQ(result, expected);
+        }
+      }
+    }
+  }
+}
+
+TEST(EmitterXmm32, div) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  std::vector<float> vals = {1.f, 0.2f, -1.f, 1235423.2f, -3457343.3f, 7.545f};
+
+  for (auto f : vals) {
+    for (auto g : vals) {
+      for (int i = 0; i < 16; i++) {
+        for (int j = 0; j < 16; j++) {
+          if (i == j) {
+            continue;
+          }
+          auto expected = g / f;
+          tester.clear();
+          tester.emit_push_all_xmms();
+          tester.emit_push_all_gprs(true);
+          u64 val = 0;
+          memcpy(&val, &f, sizeof(float));
+          tester.emit(IGen::mov_gpr64_u64(RAX, val));
+          tester.emit(IGen::movd_xmm32_gpr32(XMM0 + i, RAX));
+          memcpy(&val, &g, sizeof(float));
+          tester.emit(IGen::mov_gpr64_u64(RAX, val));
+          tester.emit(IGen::movd_xmm32_gpr32(XMM0 + j, RAX));
+          tester.emit(IGen::divss_xmm_xmm(XMM0 + j, XMM0 + i));
+          tester.emit(IGen::movd_gpr32_xmm32(RAX, XMM0 + j));
+          tester.emit_pop_all_gprs(true);
+          tester.emit_pop_all_xmms();
+          tester.emit_return();
+          auto result = tester.execute_ret<float>(0, 0, 0, 0);
+          EXPECT_EQ(result, expected);
+        }
+      }
+    }
+  }
+}
+
+TEST(EmitterXmm32, add) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  std::vector<float> vals = {0.f, 1.f, 0.2f, -1.f, 1235423.2f, -3457343.3f, 7.545f};
+  for (auto f : vals) {
+    for (auto g : vals) {
+      for (int i = 0; i < 16; i++) {
+        for (int j = 0; j < 16; j++) {
+          if (i == j) {
+            continue;
+          }
+          auto expected = g + f;
+          tester.clear();
+          tester.emit_push_all_xmms();
+          tester.emit_push_all_gprs(true);
+          u64 val = 0;
+          memcpy(&val, &f, sizeof(float));
+          tester.emit(IGen::mov_gpr64_u64(RAX, val));
+          tester.emit(IGen::movd_xmm32_gpr32(XMM0 + i, RAX));
+          memcpy(&val, &g, sizeof(float));
+          tester.emit(IGen::mov_gpr64_u64(RAX, val));
+          tester.emit(IGen::movd_xmm32_gpr32(XMM0 + j, RAX));
+          tester.emit(IGen::addss_xmm_xmm(XMM0 + j, XMM0 + i));
+          tester.emit(IGen::movd_gpr32_xmm32(RAX, XMM0 + j));
+          tester.emit_pop_all_gprs(true);
+          tester.emit_pop_all_xmms();
+          tester.emit_return();
+          auto result = tester.execute_ret<float>(0, 0, 0, 0);
+          EXPECT_EQ(result, expected);
+        }
+      }
+    }
+  }
+}
+
+TEST(EmitterXmm32, sub) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  std::vector<float> vals = {0.f, 1.f, 0.2f, -1.f, 1235423.2f, -3457343.3f, 7.545f};
+
+  for (auto f : vals) {
+    for (auto g : vals) {
+      for (int i = 0; i < 16; i++) {
+        for (int j = 0; j < 16; j++) {
+          if (i == j) {
+            continue;
+          }
+          auto expected = g - f;
+          tester.clear();
+          tester.emit_push_all_xmms();
+          tester.emit_push_all_gprs(true);
+          u64 val = 0;
+          memcpy(&val, &f, sizeof(float));
+          tester.emit(IGen::mov_gpr64_u64(RAX, val));
+          tester.emit(IGen::movd_xmm32_gpr32(XMM0 + i, RAX));
+          memcpy(&val, &g, sizeof(float));
+          tester.emit(IGen::mov_gpr64_u64(RAX, val));
+          tester.emit(IGen::movd_xmm32_gpr32(XMM0 + j, RAX));
+          tester.emit(IGen::subss_xmm_xmm(XMM0 + j, XMM0 + i));
+          tester.emit(IGen::movd_gpr32_xmm32(RAX, XMM0 + j));
+          tester.emit_pop_all_gprs(true);
+          tester.emit_pop_all_xmms();
+          tester.emit_return();
+          auto result = tester.execute_ret<float>(0, 0, 0, 0);
+          EXPECT_EQ(result, expected);
+        }
+      }
+    }
+  }
+}
+
+TEST(EmitterXmm32, float_to_int) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  std::vector<float> vals = {0.f,    1.f,  0.2f, -1.f,  1235423.2f, -3457343.3f,
+                             7.545f, 0.1f, 0.9f, -0.1f, -0.9f};
+
+  for (auto g : vals) {
+    for (int i = 0; i < 16; i++) {
+      for (int j = 0; j < 16; j++) {
+        if (j == RSP) {
+          continue;
+        }
+        s32 expected = g;
+        tester.clear();
+        tester.emit_push_all_xmms();
+        tester.emit_push_all_gprs(true);
+        u64 val = 0;
+        memcpy(&val, &g, sizeof(float));
+        tester.emit(IGen::mov_gpr64_u64(RAX, val));
+        tester.emit(IGen::movd_xmm32_gpr32(XMM0 + i, RAX));
+        tester.emit(IGen::float_to_int32(j, XMM0 + i));
+        tester.emit(IGen::mov_gpr64_gpr64(RAX, j));
+        tester.emit_pop_all_gprs(true);
+        tester.emit_pop_all_xmms();
+        tester.emit_return();
+        auto result = tester.execute_ret<s32>(0, 0, 0, 0);
+        EXPECT_EQ(result, expected);
+      }
+    }
+  }
+}
+
+TEST(EmitterXmm32, int_to_float) {
+  CodeTester tester;
+  tester.init_code_buffer(512);
+
+  std::vector<s64> vals = {0, 1, -1, INT32_MAX, -3457343, 7, INT32_MIN};
+
+  for (auto g : vals) {
+    for (int i = 0; i < 16; i++) {
+      for (int j = 0; j < 16; j++) {
+        if (j == RSP) {
+          continue;
+        }
+        float expected = g;
+        tester.clear();
+        tester.emit_push_all_xmms();
+        tester.emit_push_all_gprs(true);
+        tester.emit(IGen::mov_gpr64_u64(j, g));
+        tester.emit(IGen::int32_to_float(XMM0 + i, j));
+        tester.emit(IGen::movd_gpr32_xmm32(RAX, XMM0 + i));
+        tester.emit_pop_all_gprs(true);
+        tester.emit_pop_all_xmms();
+        tester.emit_return();
+        auto result = tester.execute_ret<float>(0, 0, 0, 0);
+        EXPECT_EQ(result, expected);
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/test_kernel.cpp b/test/test_kernel.cpp
index e5d08c6ec4..5bc2e09670 100644
--- a/test/test_kernel.cpp
+++ b/test/test_kernel.cpp
@@ -3,6 +3,7 @@
 #include <unordered_set>
 #include "gtest/gtest.h"
 #include "common/symbols.h"
+#include "common/goal_constants.h"
 #include "game/kernel/fileio.h"
 #include "game/kernel/kboot.h"
 #include "game/kernel/kprint.h"
@@ -263,8 +264,7 @@ TEST(Kernel, itoa_base_16) {
   EXPECT_EQ("1", std::string(buffer));
 
   kitoa(buffer, -1, 16, -1, ' ', 0);
-  EXPECT_EQ("ffffffffffffffff",
-            std::string(buffer));
+  EXPECT_EQ("ffffffffffffffff", std::string(buffer));
 
   kitoa(buffer, -1, 16, 5, ' ', 0);
   EXPECT_EQ("-fffff", std::string(buffer));
@@ -282,8 +282,7 @@ TEST(Kernel, itoa_base_16) {
   EXPECT_EQ("jjjjbadbeef", std::string(buffer));
 
   kitoa(buffer, INT64_MIN, 16, 0, ' ', 0);
-  EXPECT_EQ("8000000000000000",
-            std::string(buffer));
+  EXPECT_EQ("8000000000000000", std::string(buffer));
 }
 
 namespace {
@@ -343,7 +342,6 @@ TEST(Kernel, PrintBuffer) {
   // more complicated tests for format will be done from within GOAL.
 }
 
-
 TEST(Kernel, HashTable) {
   constexpr int size = 32 * 1024 * 1024;
   auto mem = new u8[size];
@@ -360,7 +358,7 @@ TEST(Kernel, HashTable) {
   std::unordered_map<std::string, u32> symbol_locations;
   std::unordered_set<u32> unique_locations;
 
-  for(auto name : all_syms) {
+  for (auto name : all_syms) {
     auto loc = intern_from_c(name).offset;
     symbol_locations[name] = loc;
     unique_locations.insert(loc);
@@ -369,7 +367,7 @@ TEST(Kernel, HashTable) {
   EXPECT_EQ(7941, symbol_locations.size());
   EXPECT_EQ(7941, unique_locations.size());
 
-  for(auto name : all_syms) {
+  for (auto name : all_syms) {
     EXPECT_EQ(symbol_locations.at(name), intern_from_c(name).offset);
   }
 
@@ -380,11 +378,10 @@ TEST(Kernel, HashTable) {
 
   // expect no crc32 hash collisions. This doesn't matter, but it's nice to know.
   std::unordered_set<u32> crc32s;
-  for(auto name : all_syms) {
+  for (auto name : all_syms) {
     crc32s.insert(crc32((const u8*)name, strlen(name)));
   }
   EXPECT_EQ(7941, crc32s.size());
 
   delete[] mem;
 }
-
diff --git a/test/test_listener_deci2.cpp b/test/test_listener_deci2.cpp
index 0422beec05..7888a9fd87 100644
--- a/test/test_listener_deci2.cpp
+++ b/test/test_listener_deci2.cpp
@@ -2,7 +2,7 @@
 
 #include "gtest/gtest.h"
 #include "goalc/listener/Listener.h"
-#include "goalc/listener/Deci2Server.h"
+#include "game/system/Deci2Server.h"
 
 using namespace listener;
 
@@ -10,7 +10,7 @@ namespace {
 bool always_false() {
   return false;
 }
-}
+}  // namespace
 
 TEST(Listener, ListenerCreation) {
   listener::Listener l;
@@ -25,7 +25,7 @@ TEST(Listener, DeciInit) {
   EXPECT_TRUE(s.init());
 }
 
-//TEST(Listener, TwoDeciServers) {
+// TEST(Listener, TwoDeciServers) {
 //  Deci2Server s1, s2;
 //  EXPECT_TRUE(s1.init());
 //  EXPECT_TRUE(s2.init());
@@ -36,6 +36,11 @@ TEST(Listener, DeciInit) {
  */
 TEST(Listener, ListenToNothing) {
   Listener l;
+  if (l.connect_to_target()) {
+    printf(
+        "~~~~~~ Test connected to a runtime when there shouldn't be anything running! Check that "
+        "you don't have gk running in the background!\n");
+  }
   EXPECT_FALSE(l.connect_to_target());
   l.disconnect();
 }
@@ -49,7 +54,7 @@ TEST(Listener, DeciCheckNoListener) {
 }
 
 TEST(Listener, DeciThenListener) {
-  for(int i = 0; i < 10; i++) {
+  for (int i = 0; i < 10; i++) {
     Deci2Server s(always_false);
     EXPECT_TRUE(s.init());
     EXPECT_FALSE(s.check_for_listener());
@@ -60,8 +65,8 @@ TEST(Listener, DeciThenListener) {
     EXPECT_FALSE(s.check_for_listener());
     EXPECT_TRUE(l.connect_to_target());
     // kind of a hack.
-    while(!s.check_for_listener()) {
-      printf("...\n");
+    while (!s.check_for_listener()) {
+      // printf("...\n");
     }
 
     EXPECT_TRUE(s.check_for_listener());
@@ -69,7 +74,7 @@ TEST(Listener, DeciThenListener) {
 }
 
 TEST(Listener, DeciThenListener2) {
-  for(int i = 0; i < 10; i++) {
+  for (int i = 0; i < 10; i++) {
     Deci2Server s(always_false);
     EXPECT_TRUE(s.init());
     EXPECT_FALSE(s.check_for_listener());
@@ -83,15 +88,15 @@ TEST(Listener, DeciThenListener2) {
 }
 
 TEST(Listener, ListenerThenDeci) {
-  for(int i = 0; i < 10; i++) {
+  for (int i = 0; i < 10; i++) {
     Listener l;
     EXPECT_FALSE(l.connect_to_target());
     Deci2Server s(always_false);
     EXPECT_TRUE(s.init());
     EXPECT_FALSE(s.check_for_listener());
     EXPECT_TRUE(l.connect_to_target());
-    while(!s.check_for_listener()) {
-      printf("...\n");
+    while (!s.check_for_listener()) {
+      //      printf("...\n");
     }
   }
 }
@@ -104,8 +109,8 @@ TEST(Listener, ListenerMultipleDecis) {
     EXPECT_TRUE(s.init());
     EXPECT_FALSE(s.check_for_listener());
     EXPECT_TRUE(l.connect_to_target());
-    while(!s.check_for_listener()) {
-      printf("...\n");
+    while (!s.check_for_listener()) {
+      // printf("...\n");
     }
     l.disconnect();
   }
@@ -115,8 +120,8 @@ TEST(Listener, ListenerMultipleDecis) {
     EXPECT_TRUE(s.init());
     EXPECT_FALSE(s.check_for_listener());
     EXPECT_TRUE(l.connect_to_target());
-    while(!s.check_for_listener()) {
-      printf("...\n");
+    while (!s.check_for_listener()) {
+      // printf("...\n");
     }
     l.disconnect();
   }
diff --git a/test/test_reader.cpp b/test/test_reader.cpp
index b49eda1242..59ce97e9de 100644
--- a/test/test_reader.cpp
+++ b/test/test_reader.cpp
@@ -316,8 +316,7 @@ TEST(GoosReader, TopLevel) {
 
 TEST(GoosReader, FromFile) {
   Reader reader;
-  auto result =
-      reader.read_from_file(util::combine_path({"test", "test_reader_file0.gc"})).print();
+  auto result = reader.read_from_file(util::combine_path({"test", "test_reader_file0.gc"})).print();
   EXPECT_TRUE(result == "(top-level (1 2 3 4))");
 }
 
diff --git a/test/test_type_system.cpp b/test/test_type_system.cpp
index 0deabcddce..784aa130fb 100644
--- a/test/test_type_system.cpp
+++ b/test/test_type_system.cpp
@@ -3,23 +3,316 @@
 #include "third-party/fmt/core.h"
 
 TEST(TypeSystem, Construction) {
+  // test that we can add all builtin types without any type errors
   TypeSystem ts;
   ts.add_builtin_types();
-  fmt::print("{}", ts.print_all_type_information());
+
+  // useful for debugging.
+  //  fmt::print("{}", ts.print_all_type_information());
 }
 
 TEST(TypeSystem, DefaultMethods) {
   TypeSystem ts;
   ts.add_builtin_types();
 
+  // check that default methods have the right ID's used by the kernel
+  ts.assert_method_id("object", "new", GOAL_NEW_METHOD);
+  ts.assert_method_id("object", "delete", GOAL_DEL_METHOD);
+  ts.assert_method_id("object", "print", GOAL_PRINT_METHOD);
+  ts.assert_method_id("object", "inspect", GOAL_INSPECT_METHOD);
+  ts.assert_method_id("object", "length", GOAL_LENGTH_METHOD);
+  ts.assert_method_id("object", "asize-of", GOAL_ASIZE_METHOD);
+  ts.assert_method_id("object", "copy", GOAL_COPY_METHOD);
+  ts.assert_method_id("object", "relocate", GOAL_RELOC_METHOD);
+  ts.assert_method_id("object", "mem-usage", GOAL_MEMUSAGE_METHOD);
 
-  ts.assert_method_id("object", "new", 0);
-  ts.assert_method_id("object", "delete", 1);
-  ts.assert_method_id("object", "print", 2);
-  ts.assert_method_id("object", "inspect", 3);
-  ts.assert_method_id("object", "length", 4);
-  ts.assert_method_id("object", "asize-of", 5);
-  ts.assert_method_id("object", "copy", 6);
-  ts.assert_method_id("object", "relocate", 7);
-  ts.assert_method_id("object", "mem-usage", 8);
-}
\ No newline at end of file
+  // check that they are inherited.
+  ts.assert_method_id("function", "new", GOAL_NEW_METHOD);
+  ts.assert_method_id("function", "delete", GOAL_DEL_METHOD);
+  ts.assert_method_id("function", "print", GOAL_PRINT_METHOD);
+  ts.assert_method_id("function", "inspect", GOAL_INSPECT_METHOD);
+  ts.assert_method_id("function", "length", GOAL_LENGTH_METHOD);
+  ts.assert_method_id("function", "asize-of", GOAL_ASIZE_METHOD);
+  ts.assert_method_id("function", "copy", GOAL_COPY_METHOD);
+  ts.assert_method_id("function", "relocate", GOAL_RELOC_METHOD);
+  ts.assert_method_id("function", "mem-usage", GOAL_MEMUSAGE_METHOD);
+}
+
+TEST(TypeSystem, TypeSpec) {
+  TypeSystem ts;
+  ts.add_builtin_types();
+
+  // try some simple typespecs
+  auto string_typespec = ts.make_typespec("string");
+  auto function_typespec = ts.make_typespec("function");
+  EXPECT_EQ(string_typespec.print(), "string");
+  EXPECT_EQ(string_typespec.base_type(), "string");
+  EXPECT_TRUE(function_typespec == function_typespec);
+  EXPECT_FALSE(function_typespec == string_typespec);
+
+  // try some pointer typespecs
+  auto pointer_function_typespec = ts.make_pointer_typespec("function");
+  EXPECT_EQ(pointer_function_typespec.print(), "(pointer function)");
+  EXPECT_EQ(pointer_function_typespec.get_single_arg(), ts.make_typespec("function"));
+  EXPECT_EQ(pointer_function_typespec.base_type(), "pointer");
+
+  // try some function typespecs
+  auto test_function_typespec = ts.make_function_typespec({"string", "symbol"}, "integer");
+  EXPECT_EQ(test_function_typespec.base_type(), "function");
+  EXPECT_EQ(test_function_typespec.print(), "(function string symbol integer)");
+
+  // try the none typespec
+  EXPECT_EQ(ts.make_typespec("none").base_type(), "none");
+}
+
+TEST(TypeSystem, TypeSpecEquality) {
+  TypeSystem ts;
+  ts.add_builtin_types();
+
+  auto pointer_to_function = ts.make_pointer_typespec("function");
+  auto ia_to_function = ts.make_inline_array_typespec("function");
+  auto pointer_to_string = ts.make_pointer_typespec("string");
+
+  EXPECT_TRUE(pointer_to_function == pointer_to_function);
+  EXPECT_FALSE(pointer_to_function == ia_to_function);
+  EXPECT_FALSE(pointer_to_string == pointer_to_function);
+}
+
+TEST(TypeSystem, RuntimeTypes) {
+  TypeSystem ts;
+  ts.add_builtin_types();
+
+  // pointers and inline arrays should all become simple pointers
+  EXPECT_EQ(ts.get_runtime_type(ts.make_typespec("pointer")), "pointer");
+  EXPECT_EQ(ts.get_runtime_type(ts.make_typespec("inline-array")), "pointer");
+  EXPECT_EQ(ts.get_runtime_type(ts.make_pointer_typespec("function")), "pointer");
+  EXPECT_EQ(ts.get_runtime_type(ts.make_inline_array_typespec("function")), "pointer");
+
+  // functions of any kind should become function
+  EXPECT_EQ(ts.get_runtime_type(ts.make_function_typespec({"integer", "string"}, "symbol")),
+            "function");
+}
+
+TEST(TypeSystem, ForwardDeclaration) {
+  TypeSystem ts;
+  ts.add_builtin_types();
+
+  // before forward declaring, lookup and creating a typespec should fail
+  EXPECT_ANY_THROW(ts.lookup_type("test-type"));
+  EXPECT_ANY_THROW(ts.make_typespec("test-type"));
+
+  // after forward declaring, we should be able to create typespec, but not do a full lookup
+  ts.forward_declare_type("test-type");
+
+  EXPECT_TRUE(ts.make_typespec("test-type").print() == "test-type");
+  EXPECT_ANY_THROW(ts.lookup_type("test-type"));
+}
+
+TEST(TypeSystem, DerefInfoNoLoadInfoOrStride) {
+  // test the parts of deref info, other than the part where it tells you how to load or the stride.
+  TypeSystem ts;
+  ts.add_builtin_types();
+
+  // can't dereference a non-pointer
+  EXPECT_FALSE(ts.get_deref_info(ts.make_typespec("string")).can_deref);
+  // can't deref a pointer with no type
+  EXPECT_FALSE(ts.get_deref_info(ts.make_typespec("pointer")).can_deref);
+  EXPECT_FALSE(ts.get_deref_info(ts.make_typespec("inline-array")).can_deref);
+
+  // test pointer to reference type
+  auto type_spec =
+      ts.make_pointer_typespec(ts.make_function_typespec({"string", "symbol"}, "int32"));
+  auto info = ts.get_deref_info(type_spec);
+  EXPECT_TRUE(info.can_deref);
+  EXPECT_TRUE(info.mem_deref);
+  EXPECT_FALSE(info.sign_extend);  // it's a memory address being loaded
+  EXPECT_EQ(info.reg, RegKind::GPR_64);
+  EXPECT_EQ(info.stride, 4);
+  EXPECT_EQ(info.result_type.print(), "(function string symbol int32)");
+  EXPECT_EQ(info.load_size, 4);
+
+  // test pointer to value type
+  type_spec = ts.make_pointer_typespec("int64");
+  info = ts.get_deref_info(type_spec);
+  EXPECT_TRUE(info.can_deref);
+  EXPECT_TRUE(info.mem_deref);
+  EXPECT_EQ(info.load_size, 8);
+  EXPECT_EQ(info.stride, 8);
+  EXPECT_EQ(info.sign_extend, true);
+  EXPECT_EQ(info.reg, RegKind::GPR_64);
+  EXPECT_EQ(info.result_type.print(), "int64");
+
+  // test inline-array (won't work because type is dynamically sized)
+  type_spec = ts.make_inline_array_typespec("type");
+  info = ts.get_deref_info(type_spec);
+  EXPECT_FALSE(info.can_deref);
+
+  // TODO - replace with a better type.
+  // TODO - maybe block basic or structure from being inline-array-able?
+  type_spec = ts.make_inline_array_typespec("basic");
+  auto type = ts.lookup_type("basic");
+  info = ts.get_deref_info(type_spec);
+  EXPECT_TRUE(info.can_deref);
+  EXPECT_FALSE(info.mem_deref);
+  EXPECT_EQ(info.stride, (type->get_size_in_memory() + 15) & (~15));
+  EXPECT_EQ(info.result_type.print(), "basic");
+  EXPECT_EQ(info.load_size, -1);
+}
+
+TEST(TypeSystem, AddMethodAndLookupMethod) {
+  TypeSystem ts;
+  ts.add_builtin_types();
+
+  auto parent_info = ts.add_method(ts.lookup_type("structure"), "test-method-1",
+                                   ts.make_function_typespec({"integer"}, "string"));
+
+  // when trying to add the same method to a child, should return the parent's method
+  auto child_info_same = ts.add_method(ts.lookup_type("basic"), "test-method-1",
+                                       ts.make_function_typespec({"integer"}, "string"));
+
+  EXPECT_EQ(parent_info.id, child_info_same.id);
+  EXPECT_EQ(parent_info.id, GOAL_MEMUSAGE_METHOD + 1);
+
+  // any amount of fiddling with method types should cause an error
+  EXPECT_ANY_THROW(ts.add_method(ts.lookup_type("basic"), "test-method-1",
+                                 ts.make_function_typespec({"integer"}, "integer")));
+  EXPECT_ANY_THROW(ts.add_method(ts.lookup_type("basic"), "test-method-1",
+                                 ts.make_function_typespec({}, "string")));
+  EXPECT_ANY_THROW(ts.add_method(ts.lookup_type("basic"), "test-method-1",
+                                 ts.make_function_typespec({"integer", "string"}, "string")));
+  EXPECT_ANY_THROW(ts.add_method(ts.lookup_type("basic"), "test-method-1",
+                                 ts.make_function_typespec({"string"}, "string")));
+
+  ts.add_method(ts.lookup_type("basic"), "test-method-2",
+                ts.make_function_typespec({"integer"}, "string"));
+
+  EXPECT_EQ(parent_info.id, ts.lookup_method("basic", "test-method-1").id);
+  EXPECT_EQ(parent_info.id, ts.lookup_method("structure", "test-method-1").id);
+  EXPECT_EQ(parent_info.id + 1, ts.lookup_method("basic", "test-method-2").id);
+  EXPECT_ANY_THROW(ts.lookup_method("structure", "test-method-2"));
+
+  EXPECT_EQ(ts.lookup_method("basic", "test-method-1").defined_in_type, "structure");
+  EXPECT_EQ(ts.lookup_method("basic", "test-method-1").type.print(), "(function integer string)");
+  EXPECT_EQ(ts.lookup_method("basic", "test-method-1").name, "test-method-1");
+}
+
+TEST(TypeSystem, NewMethod) {
+  TypeSystem ts;
+  ts.add_builtin_types();
+  ts.add_type("test-1", std::make_unique<BasicType>("basic", "test-1"));
+  ts.add_method(ts.lookup_type("test-1"), "new",
+                ts.make_function_typespec({"symbol", "string"}, "test-1"));
+  ts.add_type("test-2", std::make_unique<BasicType>("test-1", "test-2"));
+  ts.add_method(ts.lookup_type("test-2"), "new",
+                ts.make_function_typespec({"symbol", "string", "symbol"}, "test-2"));
+
+  EXPECT_EQ(ts.lookup_method("test-1", "new").type.print(), "(function symbol string test-1)");
+  EXPECT_EQ(ts.lookup_method("test-2", "new").type.print(),
+            "(function symbol string symbol test-2)");
+
+  ts.add_type("test-3", std::make_unique<BasicType>("test-1", "test-3"));
+  EXPECT_EQ(ts.lookup_method("test-3", "new").type.print(), "(function symbol string test-1)");
+
+  ts.add_type("test-4", std::make_unique<BasicType>("test-2", "test-4"));
+  EXPECT_EQ(ts.lookup_method("test-4", "new").type.print(),
+            "(function symbol string symbol test-2)");
+}
+
+TEST(TypeSystem, MethodSubstitute) {
+  TypeSystem ts;
+  ts.add_builtin_types();
+  ts.add_type("test-1", std::make_unique<BasicType>("basic", "test-1"));
+  ts.add_method(ts.lookup_type("test-1"), "new",
+                ts.make_function_typespec({"symbol", "string", "_type_"}, "_type_"));
+
+  auto final_type = ts.lookup_method("test-1", "new").type.substitute_for_method_call("test-1");
+  EXPECT_EQ(final_type.print(), "(function symbol string test-1 test-1)");
+}
+
+namespace {
+bool ts_name_name(TypeSystem& ts, const std::string& ex, const std::string& act) {
+  return ts.typecheck(ts.make_typespec(ex), ts.make_typespec(act), "", false, false);
+}
+}  // namespace
+
+TEST(TypeSystem, TypeCheck) {
+  TypeSystem ts;
+  ts.add_builtin_types();
+
+  EXPECT_TRUE(ts_name_name(ts, "none",
+                           "none"));  // none - none _shouldn't_ fail (for function return types!)
+  EXPECT_TRUE(ts_name_name(ts, "object", "object"));
+  EXPECT_TRUE(ts_name_name(ts, "object", "type"));
+  EXPECT_TRUE(ts_name_name(ts, "basic", "type"));
+  EXPECT_FALSE(ts_name_name(ts, "type", "basic"));
+  EXPECT_TRUE(ts_name_name(ts, "type", "type"));
+
+  auto f = ts.make_typespec("function");
+  auto f_s_n = ts.make_function_typespec({"string"}, "none");
+  auto f_b_n = ts.make_function_typespec({"basic"}, "none");
+
+  // complex
+  EXPECT_TRUE(ts.typecheck(f, f_s_n));
+  EXPECT_TRUE(ts.typecheck(f_s_n, f_s_n));
+  EXPECT_TRUE(ts.typecheck(f_b_n, f_s_n));
+
+  EXPECT_FALSE(ts.typecheck(f_s_n, f, "", false, false));
+  EXPECT_FALSE(ts.typecheck(f_s_n, f_b_n, "", false, false));
+
+  // number of parameter mismatch
+  auto f_s_s_n = ts.make_function_typespec({"string", "string"}, "none");
+  EXPECT_FALSE(ts.typecheck(f_s_n, f_s_s_n, "", false, false));
+  EXPECT_FALSE(ts.typecheck(f_s_s_n, f_s_n, "", false, false));
+}
+
+TEST(TypeSystem, FieldLookup) {
+  // note - this test isn't testing the specific needs_deref, type of the returned info.  Until more
+  // stuff is set up that test is kinda useless - it would just be testing against the exact
+  // implementation of lookup_field_info
+
+  TypeSystem ts;
+  ts.add_builtin_types();
+
+  EXPECT_EQ(ts.lookup_field_info("type", "parent").field.offset(), 8);
+  EXPECT_EQ(ts.lookup_field_info("string", "data").type.print(), "(pointer uint8)");
+
+  EXPECT_ANY_THROW(ts.lookup_field_info("type", "not-a-real-field"));
+}
+
+TEST(TypeSystem, get_path_up_tree) {
+  TypeSystem ts;
+  ts.add_builtin_types();
+  EXPECT_EQ(ts.get_path_up_tree("type"),
+            std::vector<std::string>({"type", "basic", "structure", "object"}));
+}
+
+TEST(TypeSystem, lca) {
+  TypeSystem ts;
+  ts.add_builtin_types();
+  EXPECT_EQ(
+      ts.lowest_common_ancestor(ts.make_typespec("string"), ts.make_typespec("basic")).print(),
+      "basic");
+  EXPECT_EQ(
+      ts.lowest_common_ancestor(ts.make_typespec("basic"), ts.make_typespec("string")).print(),
+      "basic");
+  EXPECT_EQ(
+      ts.lowest_common_ancestor(ts.make_typespec("string"), ts.make_typespec("int32")).print(),
+      "object");
+  EXPECT_EQ(
+      ts.lowest_common_ancestor(ts.make_typespec("int32"), ts.make_typespec("string")).print(),
+      "object");
+  EXPECT_EQ(
+      ts.lowest_common_ancestor({ts.make_typespec("int32"), ts.make_typespec("string")}).print(),
+      "object");
+  EXPECT_EQ(ts.lowest_common_ancestor({ts.make_typespec("int32")}).print(), "int32");
+  EXPECT_EQ(ts.lowest_common_ancestor({ts.make_typespec("string"), ts.make_typespec("kheap"),
+                                       ts.make_typespec("pointer")})
+                .print(),
+            "object");
+
+  EXPECT_EQ(ts.lowest_common_ancestor(ts.make_pointer_typespec("int32"),
+                                      ts.make_pointer_typespec("string"))
+                .print(),
+            "(pointer object)");
+}
+// TODO - a big test to make sure all the builtin types are what we expect.
diff --git a/third-party/run-clang-format/run-clang-format.py b/third-party/run-clang-format/run-clang-format.py
new file mode 100755
index 0000000000..b8364126ed
--- /dev/null
+++ b/third-party/run-clang-format/run-clang-format.py
@@ -0,0 +1,426 @@
+#!/usr/bin/env python
+"""A wrapper script around clang-format, suitable for linting multiple files
+and to use for continuous integration.
+
+This is an alternative API for the clang-format command line.
+It runs over multiple files and directories in parallel.
+A diff output is produced and a sensible exit code is returned.
+
+See - https://github.com/Sarcasm/run-clang-format
+
+MIT License
+
+Copyright (c) 2017 Guillaume Papin
+
+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.
+
+"""
+
+from __future__ import print_function, unicode_literals
+
+import argparse
+import codecs
+import difflib
+import fnmatch
+import io
+import errno
+import multiprocessing
+import os
+import signal
+import subprocess
+import sys
+import traceback
+
+from functools import partial
+
+try:
+    from subprocess import DEVNULL  # py3k
+except ImportError:
+    DEVNULL = open(os.devnull, "wb")
+
+
+DEFAULT_EXTENSIONS = 'c,h,C,H,cpp,hpp,cc,hh,c++,h++,cxx,hxx'
+DEFAULT_CLANG_FORMAT_IGNORE = '.clang-format-ignore'
+
+
+class ExitStatus:
+    SUCCESS = 0
+    DIFF = 1
+    TROUBLE = 2
+
+def excludes_from_file(ignore_file):
+    excludes = []
+    try:
+        with io.open(ignore_file, 'r', encoding='utf-8') as f:
+            for line in f:
+                if line.startswith('#'):
+                    # ignore comments
+                    continue
+                pattern = line.rstrip()
+                if not pattern:
+                    # allow empty lines
+                    continue
+                excludes.append(pattern)
+    except EnvironmentError as e:
+        if e.errno != errno.ENOENT:
+            raise
+    return excludes;
+
+def list_files(files, recursive=False, extensions=None, exclude=None):
+    if extensions is None:
+        extensions = []
+    if exclude is None:
+        exclude = []
+
+    out = []
+    for file in files:
+        if recursive and os.path.isdir(file):
+            for dirpath, dnames, fnames in os.walk(file):
+                fpaths = [os.path.join(dirpath, fname) for fname in fnames]
+                for pattern in exclude:
+                    # os.walk() supports trimming down the dnames list
+                    # by modifying it in-place,
+                    # to avoid unnecessary directory listings.
+                    dnames[:] = [
+                        x for x in dnames
+                        if
+                        not fnmatch.fnmatch(os.path.join(dirpath, x), pattern)
+                    ]
+                    fpaths = [
+                        x for x in fpaths if not fnmatch.fnmatch(x, pattern)
+                    ]
+                for f in fpaths:
+                    ext = os.path.splitext(f)[1][1:]
+                    if ext in extensions:
+                        out.append(f)
+        else:
+            out.append(file)
+    return out
+
+
+def make_diff(file, original, reformatted):
+    return list(
+        difflib.unified_diff(
+            original,
+            reformatted,
+            fromfile='{}\t(original)'.format(file),
+            tofile='{}\t(reformatted)'.format(file),
+            n=3))
+
+
+class DiffError(Exception):
+    def __init__(self, message, errs=None):
+        super(DiffError, self).__init__(message)
+        self.errs = errs or []
+
+
+class UnexpectedError(Exception):
+    def __init__(self, message, exc=None):
+        super(UnexpectedError, self).__init__(message)
+        self.formatted_traceback = traceback.format_exc()
+        self.exc = exc
+
+
+def run_clang_format_diff_wrapper(args, file):
+    try:
+        ret = run_clang_format_diff(args, file)
+        return ret
+    except DiffError:
+        raise
+    except Exception as e:
+        raise UnexpectedError('{}: {}: {}'.format(file, e.__class__.__name__,
+                                                  e), e)
+
+
+def run_clang_format_diff(args, file):
+    try:
+        with io.open(file, 'r', encoding='utf-8') as f:
+            original = f.readlines()
+    except IOError as exc:
+        raise DiffError(str(exc))
+    
+    if args.in_place:
+        invocation = [args.clang_format_executable, '-i', file]
+    else:
+        invocation = [args.clang_format_executable, file]
+
+    if args.dry_run:
+        print(" ".join(invocation))
+        return [], []
+
+    # Use of utf-8 to decode the process output.
+    #
+    # Hopefully, this is the correct thing to do.
+    #
+    # It's done due to the following assumptions (which may be incorrect):
+    # - clang-format will returns the bytes read from the files as-is,
+    #   without conversion, and it is already assumed that the files use utf-8.
+    # - if the diagnostics were internationalized, they would use utf-8:
+    #   > Adding Translations to Clang
+    #   >
+    #   > Not possible yet!
+    #   > Diagnostic strings should be written in UTF-8,
+    #   > the client can translate to the relevant code page if needed.
+    #   > Each translation completely replaces the format string
+    #   > for the diagnostic.
+    #   > -- http://clang.llvm.org/docs/InternalsManual.html#internals-diag-translation
+    #
+    # It's not pretty, due to Python 2 & 3 compatibility.
+    encoding_py3 = {}
+    if sys.version_info[0] >= 3:
+        encoding_py3['encoding'] = 'utf-8'
+
+    try:
+        proc = subprocess.Popen(
+            invocation,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
+            **encoding_py3)
+    except OSError as exc:
+        raise DiffError(
+            "Command '{}' failed to start: {}".format(
+                subprocess.list2cmdline(invocation), exc
+            )
+        )
+    proc_stdout = proc.stdout
+    proc_stderr = proc.stderr
+    if sys.version_info[0] < 3:
+        # make the pipes compatible with Python 3,
+        # reading lines should output unicode
+        encoding = 'utf-8'
+        proc_stdout = codecs.getreader(encoding)(proc_stdout)
+        proc_stderr = codecs.getreader(encoding)(proc_stderr)
+    # hopefully the stderr pipe won't get full and block the process
+    outs = list(proc_stdout.readlines())
+    errs = list(proc_stderr.readlines())
+    proc.wait()
+    if proc.returncode:
+        raise DiffError(
+            "Command '{}' returned non-zero exit status {}".format(
+                subprocess.list2cmdline(invocation), proc.returncode
+            ),
+            errs,
+        )
+    if args.in_place:
+        return [], errs
+    return make_diff(file, original, outs), errs
+
+
+def bold_red(s):
+    return '\x1b[1m\x1b[31m' + s + '\x1b[0m'
+
+
+def colorize(diff_lines):
+    def bold(s):
+        return '\x1b[1m' + s + '\x1b[0m'
+
+    def cyan(s):
+        return '\x1b[36m' + s + '\x1b[0m'
+
+    def green(s):
+        return '\x1b[32m' + s + '\x1b[0m'
+
+    def red(s):
+        return '\x1b[31m' + s + '\x1b[0m'
+
+    for line in diff_lines:
+        if line[:4] in ['--- ', '+++ ']:
+            yield bold(line)
+        elif line.startswith('@@ '):
+            yield cyan(line)
+        elif line.startswith('+'):
+            yield green(line)
+        elif line.startswith('-'):
+            yield red(line)
+        else:
+            yield line
+
+
+def print_diff(diff_lines, use_color):
+    if use_color:
+        diff_lines = colorize(diff_lines)
+    if sys.version_info[0] < 3:
+        sys.stdout.writelines((l.encode('utf-8') for l in diff_lines))
+    else:
+        sys.stdout.writelines(diff_lines)
+
+
+def print_trouble(prog, message, use_colors):
+    error_text = 'error:'
+    if use_colors:
+        error_text = bold_red(error_text)
+    print("{}: {} {}".format(prog, error_text, message), file=sys.stderr)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        '--clang-format-executable',
+        metavar='EXECUTABLE',
+        help='path to the clang-format executable',
+        default='clang-format')
+    parser.add_argument(
+        '--extensions',
+        help='comma separated list of file extensions (default: {})'.format(
+            DEFAULT_EXTENSIONS),
+        default=DEFAULT_EXTENSIONS)
+    parser.add_argument(
+        '-r',
+        '--recursive',
+        action='store_true',
+        help='run recursively over directories')
+    parser.add_argument(
+        '-d',
+        '--dry-run',
+        action='store_true',
+        help='just print the list of files')
+    parser.add_argument(
+        '-i',
+        '--in-place',
+        action='store_true',
+        help='format file instead of printing differences')
+    parser.add_argument('files', metavar='file', nargs='+')
+    parser.add_argument(
+        '-q',
+        '--quiet',
+        action='store_true',
+        help="disable output, useful for the exit code")
+    parser.add_argument(
+        '-j',
+        metavar='N',
+        type=int,
+        default=0,
+        help='run N clang-format jobs in parallel'
+        ' (default number of cpus + 1)')
+    parser.add_argument(
+        '--color',
+        default='auto',
+        choices=['auto', 'always', 'never'],
+        help='show colored diff (default: auto)')
+    parser.add_argument(
+        '-e',
+        '--exclude',
+        metavar='PATTERN',
+        action='append',
+        default=[],
+        help='exclude paths matching the given glob-like pattern(s)'
+        ' from recursive search')
+
+    args = parser.parse_args()
+
+    # use default signal handling, like diff return SIGINT value on ^C
+    # https://bugs.python.org/issue14229#msg156446
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+    try:
+        signal.SIGPIPE
+    except AttributeError:
+        # compatibility, SIGPIPE does not exist on Windows
+        pass
+    else:
+        signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+
+    colored_stdout = False
+    colored_stderr = False
+    if args.color == 'always':
+        colored_stdout = True
+        colored_stderr = True
+    elif args.color == 'auto':
+        colored_stdout = sys.stdout.isatty()
+        colored_stderr = sys.stderr.isatty()
+
+    version_invocation = [args.clang_format_executable, str("--version")]
+    try:
+        subprocess.check_call(version_invocation, stdout=DEVNULL)
+    except subprocess.CalledProcessError as e:
+        print_trouble(parser.prog, str(e), use_colors=colored_stderr)
+        return ExitStatus.TROUBLE
+    except OSError as e:
+        print_trouble(
+            parser.prog,
+            "Command '{}' failed to start: {}".format(
+                subprocess.list2cmdline(version_invocation), e
+            ),
+            use_colors=colored_stderr,
+        )
+        return ExitStatus.TROUBLE
+
+    retcode = ExitStatus.SUCCESS
+
+    excludes = excludes_from_file(DEFAULT_CLANG_FORMAT_IGNORE)
+    excludes.extend(args.exclude)
+
+    files = list_files(
+        args.files,
+        recursive=args.recursive,
+        exclude=excludes,
+        extensions=args.extensions.split(','))
+
+    if not files:
+        return
+
+    njobs = args.j
+    if njobs == 0:
+        njobs = multiprocessing.cpu_count() + 1
+    njobs = min(len(files), njobs)
+
+    if njobs == 1:
+        # execute directly instead of in a pool,
+        # less overhead, simpler stacktraces
+        it = (run_clang_format_diff_wrapper(args, file) for file in files)
+        pool = None
+    else:
+        pool = multiprocessing.Pool(njobs)
+        it = pool.imap_unordered(
+            partial(run_clang_format_diff_wrapper, args), files)
+        pool.close()
+    while True:
+        try:
+            outs, errs = next(it)
+        except StopIteration:
+            break
+        except DiffError as e:
+            print_trouble(parser.prog, str(e), use_colors=colored_stderr)
+            retcode = ExitStatus.TROUBLE
+            sys.stderr.writelines(e.errs)
+        except UnexpectedError as e:
+            print_trouble(parser.prog, str(e), use_colors=colored_stderr)
+            sys.stderr.write(e.formatted_traceback)
+            retcode = ExitStatus.TROUBLE
+            # stop at the first unexpected error,
+            # something could be very wrong,
+            # don't process all files unnecessarily
+            if pool:
+                pool.terminate()
+            break
+        else:
+            sys.stderr.writelines(errs)
+            if outs == []:
+                continue
+            if not args.quiet:
+                print_diff(outs, use_color=colored_stdout)
+            if retcode == ExitStatus.SUCCESS:
+                retcode = ExitStatus.DIFF
+    if pool:
+        pool.join()
+    return retcode
+
+
+if __name__ == '__main__':
+    sys.exit(main())