diff --git a/.appveyor.yml b/.appveyor.yml
index f1bf140e4..2ac5b4996 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -6,11 +6,8 @@
 version: 1.0.{build}-{branch}
 
 # branches to build
+# Only building master (and pull requests)
 branches:
-  # whitelist
-  # only:
-  #   - master
-
   # blacklist
   except:
     - gh-pages
@@ -23,6 +20,10 @@ skip_commits:
     - docs/*
     - LICENSE
     - README.md
+    - .travis.yml
+
+# Skip branches that have an open pull request.
+skip_branch_with_pr: true
 
 pull_requests:
   do_not_increment_build_number: true
@@ -82,11 +83,12 @@ configuration:
 # scripts to run after build
 after_build:
   - 7z a xenia-%appveyor_repo_branch%.zip LICENSE %APPVEYOR_BUILD_FOLDER%\build\bin\%PLATFORM%\%CONFIGURATION%\xenia.exe %APPVEYOR_BUILD_FOLDER%\build\bin\%PLATFORM%\%CONFIGURATION%\xenia.pdb
+  - 7z a xenia-vfs-dump-%appveyor_repo_branch%.zip LICENSE %APPVEYOR_BUILD_FOLDER%\build\bin\%PLATFORM%\%CONFIGURATION%\xenia-vfs-dump.exe %APPVEYOR_BUILD_FOLDER%\build\bin\%PLATFORM%\%CONFIGURATION%\xenia-vfs-dump.pdb
 
 # to run your custom scripts instead of automatic MSBuild
 # We also compile the tests here instead of later on.
 build_script:
-  - cmd: xb.bat build --config=%CONFIGURATION% --target=src\xenia-app --target=tests\xenia-cpu-ppc-tests
+  - cmd: xb.bat build --config=%CONFIGURATION% --target=src\xenia-app --target=tests\xenia-cpu-ppc-tests --target=src\xenia-vfs-dump
 
 # to disable automatic builds
 #build: off
@@ -131,6 +133,7 @@ artifacts:
 
   - path: xenia-cpu-ppc-test.log
   - path: xenia-$(appveyor_repo_branch).zip
+  - path: xenia-vfs-dump-$(appveyor_repo_branch).zip
 
 
 #---------------------------------#
@@ -143,7 +146,7 @@ deploy:
   - provider: Environment
     name: xenia-master
     release: xenia-$(appveyor_repo_branch)-v$(appveyor_build_version)
-    artifact: xenia-$(appveyor_repo_branch).zip
+    artifact: xenia-$(appveyor_repo_branch).zip,xenia-vfs-dump-$(appveyor_repo_branch).zip
     draft: false
     prerelease: true
     on:
diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
index a6359167a..866b52421 100644
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -1,5 +1,5 @@
 <!--
-# IF YOU HAVE A QUESTION THAT ISN'T A BUG REPORT, GO TO http://reddit.com/r/xenia
+# IF YOU HAVE A QUESTION THAT ISN'T A BUG REPORT, GO TO https://reddit.com/r/xenia
 #
 # DO NOT CREATE ISSUES ABOUT SPECIFIC GAMES IN THIS REPOSITORY!
 # a game specific issue would be e.g. "Game X crashes after you hit a character a certain way"
diff --git a/.travis.yml b/.travis.yml
index 87823fa70..55d848556 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -9,16 +9,16 @@ os:
   # - osx
 
 sudo: required
-dist: trusty
+dist: xenial
 addons:
   apt:
     sources:
       - ubuntu-toolchain-r-test
-      - llvm-toolchain-trusty-4.0
+      - llvm-toolchain-xenial-6.0
     packages:
-      - clang-4.0
-      - llvm-4.0-dev
-      - g++-5
+      - clang-6.0
+      - llvm-6.0-dev
+      - g++-8
       - python3
       - libc++-dev
       - libc++abi-dev
@@ -32,10 +32,10 @@ addons:
 
 matrix:
   include:
-    - env: C_COMPILER=clang-4.0 CXX_COMPILER=clang++-4.0 LINT=true
+    - env: C_COMPILER=clang-6.0 CXX_COMPILER=clang++-6.0 LINT=true
       sudo: false
-    - env: C_COMPILER=clang-4.0 CXX_COMPILER=clang++-4.0 BUILD=true CONFIG=Debug
-    - env: C_COMPILER=clang-4.0 CXX_COMPILER=clang++-4.0 BUILD=true CONFIG=Release
+    - env: C_COMPILER=clang-6.0 CXX_COMPILER=clang++-6.0 BUILD=true CONFIG=Debug
+    - env: C_COMPILER=clang-6.0 CXX_COMPILER=clang++-6.0 BUILD=true CONFIG=Release
 
 git:
   # We handle submodules ourselves in xenia-build setup.
@@ -72,3 +72,4 @@ script:
   #- ./xenia-build test --config=debug --no-build -- --enable_haswell_instructions=false
   # All tests (with haswell support).
   #- ./xenia-build test --config=debug --no-build -- --enable_haswell_instructions=true
+
diff --git a/README.md b/README.md
index 4bb7374c0..61377f5d1 100644
--- a/README.md
+++ b/README.md
@@ -2,11 +2,14 @@ Xenia - Xbox 360 Emulator Research Project
 ==========================================
 
 Xenia is an experimental emulator for the Xbox 360. For more information see the
-[main xenia website](http://xenia.jp/).
+[main xenia website](https://xenia.jp/).
+
+**Interested in supporting the core contributors?
+[Xenia Project on Patreon](https://www.patreon.com/xenia_project).**
 
 Come chat with us about **emulator-related topics** on [Discord](https://discord.gg/Q9mxZf9).
-For developer chat join `#dev` but stay on topic. Lurking is fine.
-Please check the [frequently asked questions](http://xenia.jp/faq/) page before
+For developer chat join `#dev` but stay on topic. Lurking is not only fine, but encouraged!
+Please check the [frequently asked questions](https://xenia.jp/faq/) page before
 asking questions. We've got jobs/lives/etc, so don't expect instant answers.
 
 Discussing illegal activities will get you banned. No warnings.
@@ -35,7 +38,7 @@ legally purchased devices and games and information made public on the internet
 
 Windows 8.1+ with Python 3.4 and [Visual Studio 2017](https://www.visualstudio.com/downloads/) and the Windows SDKs installed:
 
-    > git clone https://github.com/benvanik/xenia.git
+    > git clone https://github.com/xenia-project/xenia.git
     > cd xenia
     > xb setup
 
@@ -76,16 +79,16 @@ For general rules and guidelines please see [CONTRIBUTING.md](.github/CONTRIBUTI
 Fixes and optimizations are always welcome (please!), but in addition to
 that there are some major work areas still untouched:
 
-* Help work through missing functionality/bugs in game [compat](https://github.com/benvanik/xenia/issues?labels=compat)
-* Add input drivers for [PS4 controllers](https://github.com/benvanik/xenia/issues/60) (or anything else)
-* Skilled with Linux? A strong contributor is needed to [help with porting](https://github.com/benvanik/xenia/labels/cross%20platform)
+* Help work through missing functionality/bugs in game [compat](https://github.com/xenia-project/xenia/issues?labels=compat)
+* Add input drivers for [PS4 controllers](https://github.com/xenia-project/xenia/issues/60) (or anything else)
+* Skilled with Linux? A strong contributor is needed to [help with porting](https://github.com/xenia-project/xenia/labels/cross%20platform)
 
-See more projects [good for contributors](https://github.com/benvanik/xenia/labels/good%20first%20issue). It's a good idea to ask on Discord/the bugs before beginning work
+See more projects [good for contributors](https://github.com/xenia-project/xenia/labels/good%20first%20issue). It's a good idea to ask on Discord/the bugs before beginning work
 on something.
 
 ## FAQ
 
-For more see the main [frequently asked questions](http://xenia.jp/faq/) page.
+For more see the main [frequently asked questions](https://xenia.jp/faq/) page.
 
 ### Can I get an exe?
 
diff --git a/assets/icon/1024.png b/assets/icon/1024.png
new file mode 100644
index 000000000..310bc0478
Binary files /dev/null and b/assets/icon/1024.png differ
diff --git a/assets/icon/128.png b/assets/icon/128.png
new file mode 100644
index 000000000..9f20f86f6
Binary files /dev/null and b/assets/icon/128.png differ
diff --git a/assets/icon/128x128.png b/assets/icon/128x128.png
deleted file mode 100644
index c266576e6..000000000
Binary files a/assets/icon/128x128.png and /dev/null differ
diff --git a/assets/icon/16.png b/assets/icon/16.png
new file mode 100644
index 000000000..f612fcfc7
Binary files /dev/null and b/assets/icon/16.png differ
diff --git a/assets/icon/16x16.png b/assets/icon/16x16.png
deleted file mode 100644
index 77d669639..000000000
Binary files a/assets/icon/16x16.png and /dev/null differ
diff --git a/assets/icon/256.png b/assets/icon/256.png
new file mode 100644
index 000000000..ba11fd82a
Binary files /dev/null and b/assets/icon/256.png differ
diff --git a/assets/icon/256x256.png b/assets/icon/256x256.png
deleted file mode 100644
index d9cb2976e..000000000
Binary files a/assets/icon/256x256.png and /dev/null differ
diff --git a/assets/icon/32.png b/assets/icon/32.png
new file mode 100644
index 000000000..c7fad0dab
Binary files /dev/null and b/assets/icon/32.png differ
diff --git a/assets/icon/32x32.png b/assets/icon/32x32.png
deleted file mode 100644
index c82a2463a..000000000
Binary files a/assets/icon/32x32.png and /dev/null differ
diff --git a/assets/icon/36x36.png b/assets/icon/36x36.png
deleted file mode 100644
index 3a25e4c3f..000000000
Binary files a/assets/icon/36x36.png and /dev/null differ
diff --git a/assets/icon/37x37.png b/assets/icon/37x37.png
deleted file mode 100644
index f515c8632..000000000
Binary files a/assets/icon/37x37.png and /dev/null differ
diff --git a/assets/icon/48.png b/assets/icon/48.png
new file mode 100644
index 000000000..f48c73d9b
Binary files /dev/null and b/assets/icon/48.png differ
diff --git a/assets/icon/48x48.png b/assets/icon/48x48.png
deleted file mode 100644
index 5449d62c4..000000000
Binary files a/assets/icon/48x48.png and /dev/null differ
diff --git a/assets/icon/512.png b/assets/icon/512.png
new file mode 100644
index 000000000..b92eb701b
Binary files /dev/null and b/assets/icon/512.png differ
diff --git a/assets/icon/512x512.png b/assets/icon/512x512.png
deleted file mode 100644
index 103a78ca8..000000000
Binary files a/assets/icon/512x512.png and /dev/null differ
diff --git a/assets/icon/64.png b/assets/icon/64.png
new file mode 100644
index 000000000..4bd1b90a0
Binary files /dev/null and b/assets/icon/64.png differ
diff --git a/assets/icon/64x64.png b/assets/icon/64x64.png
deleted file mode 100644
index 1fdc81a25..000000000
Binary files a/assets/icon/64x64.png and /dev/null differ
diff --git a/assets/icon/Icon.blend b/assets/icon/Icon.blend
deleted file mode 100644
index a7a4a045e..000000000
Binary files a/assets/icon/Icon.blend and /dev/null differ
diff --git a/assets/icon/LICENSE b/assets/icon/LICENSE
new file mode 100644
index 000000000..fe8dbc50f
--- /dev/null
+++ b/assets/icon/LICENSE
@@ -0,0 +1,428 @@
+Attribution-ShareAlike 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+	wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public: 
+	wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution-ShareAlike 4.0 International Public
+License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution-ShareAlike 4.0 International Public License ("Public
+License"). To the extent this Public License may be interpreted as a
+contract, You are granted the Licensed Rights in consideration of Your
+acceptance of these terms and conditions, and the Licensor grants You
+such rights in consideration of benefits the Licensor receives from
+making the Licensed Material available under these terms and
+conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. BY-SA Compatible License means a license listed at
+     creativecommons.org/compatiblelicenses, approved by Creative
+     Commons as essentially the equivalent of this Public License.
+
+  d. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  e. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  f. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  g. License Elements means the license attributes listed in the name
+     of a Creative Commons Public License. The License Elements of this
+     Public License are Attribution and ShareAlike.
+
+  h. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  i. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  j. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  k. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  l. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  m. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part; and
+
+            b. produce, reproduce, and Share Adapted Material.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. Additional offer from the Licensor -- Adapted Material.
+               Every recipient of Adapted Material from You
+               automatically receives an offer from the Licensor to
+               exercise the Licensed Rights in the Adapted Material
+               under the conditions of the Adapter's License You apply.
+
+            c. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+  b. ShareAlike.
+
+     In addition to the conditions in Section 3(a), if You Share
+     Adapted Material You produce, the following conditions also apply.
+
+       1. The Adapter's License You apply must be a Creative Commons
+          license with the same License Elements, this version or
+          later, or a BY-SA Compatible License.
+
+       2. You must include the text of, or the URI or hyperlink to, the
+          Adapter's License You apply. You may satisfy this condition
+          in any reasonable manner based on the medium, means, and
+          context in which You Share Adapted Material.
+
+       3. You may not offer or impose any additional or different terms
+          or conditions on, or apply any Effective Technological
+          Measures to, Adapted Material that restrict exercise of the
+          rights granted under the Adapter's License You apply.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material,
+
+     including for purposes of Section 3(b); and
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.
+
diff --git a/assets/icon/Rendering Instructions.txt b/assets/icon/Rendering Instructions.txt
deleted file mode 100644
index bf73392af..000000000
--- a/assets/icon/Rendering Instructions.txt	
+++ /dev/null
@@ -1,26 +0,0 @@
-
-/// -------------- *** -------------- ///
-///                                   ///
-///      Rendering Instructions       ///
-///                                   ///
-/// -------------- *** -------------- ///
-
-For those not well-versed in Blender, this document explains
-how to render the icon in any desired resolution and color.
-
-To Change Resolution:
-  1. Open Icon.blend in Blender.
-  2. In the right tool pane, look for "Resolution" under the
-     "Dimensions" settings. It should be defaulted to 512x512.
-     This is where you'll change the icon output dimensions.
-  3. After you've set the value to what you want, hit F12 or
-     select 'Render' > 'Render Image' from the top bar. This
-     will render the icon.
-  4. To save, hit F3 or select 'Image' > 'Save As Image' on
-     the left toward the middle of the screen.
-
-To Change Colors:
-  1. Open Icon.blend in Blender.
-  2. The icon's colors will appear in the bottom window as
-     labeled nodes. Change them by clicking on each node.
-  3. Render and save as described above.
\ No newline at end of file
diff --git a/assets/icon/extra/114.png b/assets/icon/extra/114.png
new file mode 100644
index 000000000..619437bf5
Binary files /dev/null and b/assets/icon/extra/114.png differ
diff --git a/assets/icon/extra/120.png b/assets/icon/extra/120.png
new file mode 100644
index 000000000..0f8b5c3b0
Binary files /dev/null and b/assets/icon/extra/120.png differ
diff --git a/assets/icon/extra/144.png b/assets/icon/extra/144.png
new file mode 100644
index 000000000..8db119d04
Binary files /dev/null and b/assets/icon/extra/144.png differ
diff --git a/assets/icon/extra/150.png b/assets/icon/extra/150.png
new file mode 100644
index 000000000..537488261
Binary files /dev/null and b/assets/icon/extra/150.png differ
diff --git a/assets/icon/extra/152.png b/assets/icon/extra/152.png
new file mode 100644
index 000000000..b11bf2fe8
Binary files /dev/null and b/assets/icon/extra/152.png differ
diff --git a/assets/icon/extra/180.png b/assets/icon/extra/180.png
new file mode 100644
index 000000000..a724a341a
Binary files /dev/null and b/assets/icon/extra/180.png differ
diff --git a/assets/icon/extra/192.png b/assets/icon/extra/192.png
new file mode 100644
index 000000000..8280a3ad6
Binary files /dev/null and b/assets/icon/extra/192.png differ
diff --git a/assets/icon/extra/310.png b/assets/icon/extra/310.png
new file mode 100644
index 000000000..40537f383
Binary files /dev/null and b/assets/icon/extra/310.png differ
diff --git a/assets/icon/extra/36.png b/assets/icon/extra/36.png
new file mode 100644
index 000000000..104887e20
Binary files /dev/null and b/assets/icon/extra/36.png differ
diff --git a/assets/icon/extra/57.png b/assets/icon/extra/57.png
new file mode 100644
index 000000000..3a45f719f
Binary files /dev/null and b/assets/icon/extra/57.png differ
diff --git a/assets/icon/extra/60.png b/assets/icon/extra/60.png
new file mode 100644
index 000000000..a36f6140c
Binary files /dev/null and b/assets/icon/extra/60.png differ
diff --git a/assets/icon/extra/70.png b/assets/icon/extra/70.png
new file mode 100644
index 000000000..c8f531586
Binary files /dev/null and b/assets/icon/extra/70.png differ
diff --git a/assets/icon/extra/72.png b/assets/icon/extra/72.png
new file mode 100644
index 000000000..c5af63ba5
Binary files /dev/null and b/assets/icon/extra/72.png differ
diff --git a/assets/icon/extra/76.png b/assets/icon/extra/76.png
new file mode 100644
index 000000000..7c930ed92
Binary files /dev/null and b/assets/icon/extra/76.png differ
diff --git a/assets/icon/extra/96.png b/assets/icon/extra/96.png
new file mode 100644
index 000000000..6f6111cd8
Binary files /dev/null and b/assets/icon/extra/96.png differ
diff --git a/assets/icon/icon.ico b/assets/icon/icon.ico
index 50a1b7658..26cd5ad33 100644
Binary files a/assets/icon/icon.ico and b/assets/icon/icon.ico differ
diff --git a/assets/icon/original icon by KMA/128x128.png b/assets/icon/original icon by KMA/128x128.png
deleted file mode 100644
index 231718bb7..000000000
Binary files a/assets/icon/original icon by KMA/128x128.png and /dev/null differ
diff --git a/assets/icon/original icon by KMA/16x16.png b/assets/icon/original icon by KMA/16x16.png
deleted file mode 100644
index d28919c4b..000000000
Binary files a/assets/icon/original icon by KMA/16x16.png and /dev/null differ
diff --git a/assets/icon/original icon by KMA/256x256.png b/assets/icon/original icon by KMA/256x256.png
deleted file mode 100644
index 0c530d578..000000000
Binary files a/assets/icon/original icon by KMA/256x256.png and /dev/null differ
diff --git a/assets/icon/original icon by KMA/32x32.png b/assets/icon/original icon by KMA/32x32.png
deleted file mode 100644
index 9ae25c42e..000000000
Binary files a/assets/icon/original icon by KMA/32x32.png and /dev/null differ
diff --git a/assets/icon/original icon by KMA/36x36.png b/assets/icon/original icon by KMA/36x36.png
deleted file mode 100644
index 18f0ee0e8..000000000
Binary files a/assets/icon/original icon by KMA/36x36.png and /dev/null differ
diff --git a/assets/icon/original icon by KMA/37x37.png b/assets/icon/original icon by KMA/37x37.png
deleted file mode 100644
index 86e0c33f1..000000000
Binary files a/assets/icon/original icon by KMA/37x37.png and /dev/null differ
diff --git a/assets/icon/original icon by KMA/48x48.png b/assets/icon/original icon by KMA/48x48.png
deleted file mode 100644
index a2307c355..000000000
Binary files a/assets/icon/original icon by KMA/48x48.png and /dev/null differ
diff --git a/assets/icon/original icon by KMA/512x512.png b/assets/icon/original icon by KMA/512x512.png
deleted file mode 100644
index 647425b38..000000000
Binary files a/assets/icon/original icon by KMA/512x512.png and /dev/null differ
diff --git a/assets/icon/original icon by KMA/64x64.png b/assets/icon/original icon by KMA/64x64.png
deleted file mode 100644
index 3f662265e..000000000
Binary files a/assets/icon/original icon by KMA/64x64.png and /dev/null differ
diff --git a/assets/icon/original icon by KMA/Icon.psd b/assets/icon/original icon by KMA/Icon.psd
deleted file mode 100644
index 16afc8084..000000000
Binary files a/assets/icon/original icon by KMA/Icon.psd and /dev/null differ
diff --git a/assets/icon/original icon by KMA/Icon_Complex.psd b/assets/icon/original icon by KMA/Icon_Complex.psd
deleted file mode 100644
index f343a1363..000000000
Binary files a/assets/icon/original icon by KMA/Icon_Complex.psd and /dev/null differ
diff --git a/assets/icon/original icon by KMA/icon.ico b/assets/icon/original icon by KMA/icon.ico
deleted file mode 100644
index d35265440..000000000
Binary files a/assets/icon/original icon by KMA/icon.ico and /dev/null differ
diff --git a/docs/building.md b/docs/building.md
index 445e90705..6552de6a4 100644
--- a/docs/building.md
+++ b/docs/building.md
@@ -12,12 +12,12 @@ video drivers for your card.
 * Visual Studio 2017 
 * Windows Universal CRT SDK
 * [Python 3.4+](https://www.python.org/downloads/)
-* You will also need the [Windows 8.1 SDK](http://msdn.microsoft.com/en-us/windows/desktop/bg162891) 
+* You will also need the [Windows 8.1 SDK](https://msdn.microsoft.com/en-us/windows/desktop/bg162891)
   * (for VS2017 just click the Windows 8.1 SDK option in the Individual Components section in the Visual Studio Installer)
 
 Ensure Python is in your PATH.
 
-I recommend using [Cmder](http://cmder.net/) for git and command
+I recommend using [Cmder](https://cmder.net/) for git and command
 line usage.
 
 #### Debugging
@@ -41,7 +41,7 @@ Linux support is extremely experimental and presently incomplete.
 The build script uses LLVM/Clang 3.8. GCC should also work, but is not easily
 swappable right now.
 
-[CodeLite](http://codelite.org) is the IDE of choice and `xb premake` will spit
+[CodeLite](https://codelite.org) is the IDE of choice and `xb premake` will spit
 out files for that. Make also works via `xb build`.
 
 To get the latest Clang on an ubuntu system:
diff --git a/docs/cpu.md b/docs/cpu.md
index c1521f1e8..1b2794e66 100644
--- a/docs/cpu.md
+++ b/docs/cpu.md
@@ -123,16 +123,16 @@ The CPU is largely similar to the PPC part in the PS3, so Cell documents
 often line up for the core instructions. The 360 adds some additional AltiVec
 instructions, though, which are only documented in a few places (like the gcc source code, etc).
 
-* [Free60 Info](http://www.free60.org/Xenon_\(CPU\))
-* [Power ISA docs](https://www.power.org/wp-content/uploads/2012/07/PowerISA_V2.06B_V2_PUBLIC.pdf) (aka 'PowerISA')
-* [PowerPC Programming Environments Manual](https://www-01.ibm.com/chips/techlib/techlib.nsf/techdocs/F7E732FF811F783187256FDD004D3797/$file/pem_64bit_v3.0.2005jul15.pdf) (aka 'pem_64')
-* [PowerPC Vector PEM](https://www-01.ibm.com/chips/techlib/techlib.nsf/techdocs/C40E4C6133B31EE8872570B500791108/$file/vector_simd_pem_v_2.07c_26Oct2006_cell.pdf)
-* [AltiVec PEM](http://cache.freescale.com/files/32bit/doc/ref_manual/ALTIVECPEM.pdf)
+* [Free60 Info](https://free60project.github.io/wiki/Xenon_(CPU))
+* [Power ISA docs](https://web.archive.org/web/20140603115759/https://www.power.org/wp-content/uploads/2012/07/PowerISA_V2.06B_V2_PUBLIC.pdf) (aka 'PowerISA')
+* [PowerPC Programming Environments Manual](https://web.archive.org/web/20141028181028/https://www-01.ibm.com/chips/techlib/techlib.nsf/techdocs/F7E732FF811F783187256FDD004D3797/$file/pem_64bit_v3.0.2005jul15.pdf) (aka 'pem_64')
+* [PowerPC Vector PEM](https://web.archive.org/web/20130502201029/https://www-01.ibm.com/chips/techlib/techlib.nsf/techdocs/C40E4C6133B31EE8872570B500791108/$file/vector_simd_pem_v_2.07c_26Oct2006_cell.pdf)
+* [AltiVec PEM](https://web.archive.org/web/20151110180336/https://cache.freescale.com/files/32bit/doc/ref_manual/ALTIVECPEM.pdf)
 * [VMX128 Opcodes](http://biallas.net/doc/vmx128/vmx128.txt)
 * [AltiVec Decoding](https://github.com/kakaroto/ps3ida/blob/master/plugins/PPCAltivec/src/main.cpp)
 
 ### x64
 
-* [Intel Manuals](http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html)
-   * [Combined Intel Manuals](http://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-manual-325462.pdf)
+* [Intel Manuals](https://software.intel.com/en-us/articles/intel-sdm)
+   * [Combined Intel Manuals](https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-manual-325462.pdf)
 * [Apple AltiVec/SSE Migration Guide](https://developer.apple.com/legacy/library/documentation/Performance/Conceptual/Accelerate_sse_migration/Accelerate_sse_migration.pdf)
diff --git a/docs/gpu.md b/docs/gpu.md
index c209f57e3..903c9b6e2 100644
--- a/docs/gpu.md
+++ b/docs/gpu.md
@@ -31,7 +31,7 @@ waiting for a fixed 60hz timer.
 
 ### Vulkan
 
-See the top of [src/xenia/gpu/vulkan/vulkan_gpu_flags.cc](../src/xenia/vulkan/vulkan_gpu_flags.cc).
+See the top of [src/xenia/gpu/vulkan/vulkan_gpu_flags.cc](../src/xenia/gpu/vulkan/vulkan_gpu_flags.cc).
 
 `vulkan_dump_disasm=true` "Dump shader disassembly. NVIDIA only supported."
 
@@ -121,6 +121,6 @@ PM4 commands documented at [src/xenia/gpu/xenos.h](../src/xenia/gpu/xenos.h#L521
 
 ### Shaders
 
-* [LLVM R600 Tables](http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/AMDGPU/R600Instructions.td)
+* [LLVM R600 Tables](https://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/AMDGPU/R600Instructions.td)
 ** The opcode formats don't match, but the name->psuedo code is correct.
 * [xemit](https://github.com/gligli/libxemit/blob/master/xemitops.c)
diff --git a/docs/images/CPU-JIT.png b/docs/images/CPU-JIT.png
index 27567f8e1..4cae8682b 100644
Binary files a/docs/images/CPU-JIT.png and b/docs/images/CPU-JIT.png differ
diff --git a/docs/style_guide.md b/docs/style_guide.md
index 3252e7c93..f61590f9f 100644
--- a/docs/style_guide.md
+++ b/docs/style_guide.md
@@ -58,13 +58,13 @@ think about tabs and wrapping and such.
 
 To use the `xb format` auto-formatter, you need to have a `clang-format` on your
 PATH. If you're on Windows you can do this by installing an LLVM binary package
-from [the LLVM downloads page](http://llvm.org/releases/download.html). If you
+from [the LLVM downloads page](https://llvm.org/releases/download.html). If you
 install it to the default location the `xb format` command will find it
 automatically even if you don't choose to put all of LLVM onto your PATH.
 
 #### Visual Studio
 
-Grab the official [experimental Visual Studio plugin](http://llvm.org/builds/).
+Grab the official [experimental Visual Studio plugin](https://llvm.org/builds/).
 To switch to the Google style go Tools -> Options -> LLVM/Clang -> ClangFormat
 and set Style to Google. Then use ctrl-r/ctrl-f to trigger the formatting.
 Unfortunately it only does the cursor by default, so you'll have to select the
@@ -74,7 +74,7 @@ If you have a better option, let me know!
 
 #### Xcode
 
-Install [Alcatraz](http://alcatraz.io/) to get the [ClangFormat](https://github.com/travisjeffery/ClangFormat-Xcode)
+Install [Alcatraz](https://github.com/alcatraz/Alcatraz) to get the [ClangFormat](https://github.com/travisjeffery/ClangFormat-Xcode)
 package. Set it to use the Google style and format on save. Never think about
 tabs or linefeeds or whatever again.
 
diff --git a/premake5.lua b/premake5.lua
index 30d025979..891fbefa4 100644
--- a/premake5.lua
+++ b/premake5.lua
@@ -128,10 +128,6 @@ filter({"platforms:Linux", "toolset:gcc"})
   end
 
 filter({"platforms:Linux", "language:C++", "toolset:clang"})
-  buildoptions({
-    "-std=c++14",
-    "-stdlib=libstdc++",
-  })
   links({
     "c++",
     "c++abi"
@@ -139,6 +135,11 @@ filter({"platforms:Linux", "language:C++", "toolset:clang"})
   disablewarnings({
     "deprecated-register"
   })
+filter({"platforms:Linux", "language:C++", "toolset:clang", "files:*.cc or *.cpp"})
+  buildoptions({
+    "-std=c++14",
+    "-stdlib=libstdc++",
+  })
 
 filter("platforms:Windows")
   system("windows")
@@ -228,6 +229,7 @@ solution("xenia")
   include("third_party/glslang-spirv.lua")
   include("third_party/imgui.lua")
   include("third_party/libav.lua")
+  include("third_party/mspack.lua")
   include("third_party/snappy.lua")
   include("third_party/spirv-tools.lua")
   include("third_party/volk.lua")
diff --git a/src/xenia/app/emulator_window.cc b/src/xenia/app/emulator_window.cc
index 668c30db3..9589f6f8a 100644
--- a/src/xenia/app/emulator_window.cc
+++ b/src/xenia/app/emulator_window.cc
@@ -260,7 +260,7 @@ bool EmulatorWindow::Initialize() {
                          std::bind(&EmulatorWindow::ShowHelpWebsite, this)));
     help_menu->AddChild(MenuItem::Create(
         MenuItem::Type::kString, L"&About...",
-        [this]() { LaunchBrowser("http://xenia.jp/about/"); }));
+        [this]() { LaunchBrowser("https://xenia.jp/about/"); }));
   }
   main_menu->AddChild(std::move(help_menu));
 
@@ -384,7 +384,7 @@ void EmulatorWindow::ToggleFullscreen() {
   }
 }
 
-void EmulatorWindow::ShowHelpWebsite() { LaunchBrowser("http://xenia.jp"); }
+void EmulatorWindow::ShowHelpWebsite() { LaunchBrowser("https://xenia.jp"); }
 
 void EmulatorWindow::UpdateTitle() {
   std::wstring title(base_title_);
diff --git a/src/xenia/app/premake5.lua b/src/xenia/app/premake5.lua
index 3b4b4b9c6..c5e9eb334 100644
--- a/src/xenia/app/premake5.lua
+++ b/src/xenia/app/premake5.lua
@@ -15,6 +15,7 @@ project("xenia-app")
     "imgui",
     "libavcodec",
     "libavutil",
+    "mspack",
     "snappy",
     "spirv-tools",
     "volk",
@@ -41,6 +42,8 @@ project("xenia-app")
     "WinMain",  -- Use WinMain instead of main.
   })
   defines({
+    "XBYAK_NO_OP_NAMES",
+    "XBYAK_ENABLE_OMITTED_OPERAND",
   })
   includedirs({
     project_root.."/third_party/gflags/src",
@@ -50,6 +53,10 @@ project("xenia-app")
     "xenia_main.cc",
     "../base/main_"..platform_suffix..".cc",
   })
+
+  filter("files:xenia_main.cc or ../base/main_"..platform_suffix..".cc")
+    vectorextensions("IA32")  -- Disable AVX for main_win.cc so our AVX check/error can happen.
+
   filter("platforms:Windows")
     files({
       "main_resources.rc",
diff --git a/src/xenia/app/xenia_main.cc b/src/xenia/app/xenia_main.cc
index def29b7c5..2597fc02f 100644
--- a/src/xenia/app/xenia_main.cc
+++ b/src/xenia/app/xenia_main.cc
@@ -44,6 +44,8 @@ DEFINE_string(hid, "any", "Input system. Use: [any, nop, winkey, xinput]");
 DEFINE_string(target, "", "Specifies the target .xex or .iso to execute.");
 DEFINE_bool(fullscreen, false, "Toggles fullscreen");
 
+DEFINE_string(content_root, "", "Root path for content (save/etc) storage.");
+
 DEFINE_bool(mount_scratch, false, "Enable scratch mount");
 DEFINE_bool(mount_cache, false, "Enable cache mount");
 
@@ -117,11 +119,18 @@ std::vector<std::unique_ptr<hid::InputDriver>> CreateInputDrivers(
       drivers.emplace_back(std::move(winkey_driver));
     }
 #endif  // XE_PLATFORM_WIN32
-    if (drivers.empty()) {
-      // Fallback to nop if none created.
-      drivers.emplace_back(xe::hid::nop::Create(window));
+  }
+  for (auto it = drivers.begin(); it != drivers.end();) {
+    if (XFAILED((*it)->Setup())) {
+      it = drivers.erase(it);
+    } else {
+      ++it;
     }
   }
+  if (drivers.empty()) {
+    // Fallback to nop if none created.
+    drivers.emplace_back(xe::hid::nop::Create(window));
+  }
   return drivers;
 }
 
@@ -129,8 +138,35 @@ int xenia_main(const std::vector<std::wstring>& args) {
   Profiler::Initialize();
   Profiler::ThreadEnter("main");
 
+  // Figure out where content should go.
+  std::wstring content_root;
+  if (!FLAGS_content_root.empty()) {
+    content_root = xe::to_wstring(FLAGS_content_root);
+  } else {
+    auto base_path = xe::filesystem::GetExecutableFolder();
+    base_path = xe::to_absolute_path(base_path);
+
+    auto portable_path = xe::join_paths(base_path, L"portable.txt");
+    if (xe::filesystem::PathExists(portable_path)) {
+      content_root = xe::join_paths(base_path, L"content");
+    } else {
+      content_root = xe::filesystem::GetUserFolder();
+#if defined(XE_PLATFORM_WIN32)
+      content_root = xe::join_paths(content_root, L"Xenia");
+#elif defined(XE_PLATFORM_LINUX)
+      content_root = xe::join_paths(content_root, L".xenia");
+#else
+#warning Unhandled platform for content root.
+      content_root = xe::join_paths(content_root, L"Xenia");
+#endif
+      content_root = xe::join_paths(content_root, L"content");
+    }
+  }
+  content_root = xe::to_absolute_path(content_root);
+  XELOGI("Content root: %S", content_root.c_str());
+
   // Create the emulator but don't initialize so we can setup the window.
-  auto emulator = std::make_unique<Emulator>(L"");
+  auto emulator = std::make_unique<Emulator>(L"", content_root);
 
   // Main emulator display window.
   auto emulator_window = EmulatorWindow::Create(emulator.get());
diff --git a/src/xenia/apu/xma_context.h b/src/xenia/apu/xma_context.h
index c1e3e3dfa..d800bc0a6 100644
--- a/src/xenia/apu/xma_context.h
+++ b/src/xenia/apu/xma_context.h
@@ -25,7 +25,7 @@
 
 // Helpful resources:
 // https://github.com/koolkdev/libertyv/blob/master/libav_wrapper/xma2dec.c
-// http://hcs64.com/mboard/forum.php?showthread=14818
+// https://hcs64.com/mboard/forum.php?showthread=14818
 // https://github.com/hrydgard/minidx9/blob/master/Include/xma2defs.h
 
 // Forward declarations
@@ -41,7 +41,7 @@ namespace apu {
 // We load and swap the whole thing to splat here so that we can
 // use bitfields.
 // This could be important:
-// http://www.fmod.org/questions/question/forum-15859
+// https://www.fmod.org/questions/question/forum-15859
 // Appears to be dumped in order (for the most part)
 
 struct XMA_CONTEXT_DATA {
diff --git a/src/xenia/base/atomic.h b/src/xenia/base/atomic.h
index 8cbd1b789..f1b8bb4b7 100644
--- a/src/xenia/base/atomic.h
+++ b/src/xenia/base/atomic.h
@@ -17,7 +17,9 @@
 namespace xe {
 
 // These functions are modeled off of the Apple OSAtomic routines
-// http://developer.apple.com/library/mac/#documentation/DriversKernelHardware/Reference/libkern_ref/OSAtomic_h/
+// https://developer.apple.com/documentation/kernel/osatomic_h (?)
+// Original link (dead):
+// https://developer.apple.com/library/mac/#documentation/DriversKernelHardware/Reference/libkern_ref/OSAtomic_h/
 
 #if XE_PLATFORM_MAC
 
diff --git a/src/xenia/base/exception_handler_win.cc b/src/xenia/base/exception_handler_win.cc
index 742c54fa9..3fde109d6 100644
--- a/src/xenia/base/exception_handler_win.cc
+++ b/src/xenia/base/exception_handler_win.cc
@@ -44,8 +44,8 @@ LONG CALLBACK ExceptionHandlerCallback(PEXCEPTION_POINTERS ex_info) {
   std::memcpy(thread_context.xmm_registers, &ex_info->ContextRecord->Xmm0,
               sizeof(thread_context.xmm_registers));
 
-  // http://msdn.microsoft.com/en-us/library/ms679331(v=vs.85).aspx
-  // http://msdn.microsoft.com/en-us/library/aa363082(v=vs.85).aspx
+  // https://msdn.microsoft.com/en-us/library/ms679331(v=vs.85).aspx
+  // https://msdn.microsoft.com/en-us/library/aa363082(v=vs.85).aspx
   Exception ex;
   switch (ex_info->ExceptionRecord->ExceptionCode) {
     case STATUS_ILLEGAL_INSTRUCTION:
diff --git a/src/xenia/base/filesystem.h b/src/xenia/base/filesystem.h
index f2f2684cf..8cce19719 100644
--- a/src/xenia/base/filesystem.h
+++ b/src/xenia/base/filesystem.h
@@ -20,6 +20,15 @@
 namespace xe {
 namespace filesystem {
 
+// Get executable path.
+std::wstring GetExecutablePath();
+
+// Get executable folder.
+std::wstring GetExecutableFolder();
+
+// Get user folder.
+std::wstring GetUserFolder();
+
 // Canonicalizes a path, removing ..'s.
 std::string CanonicalizePath(const std::string& original_path);
 
diff --git a/src/xenia/base/filesystem_posix.cc b/src/xenia/base/filesystem_posix.cc
index c3c2eaf80..2e81f5089 100644
--- a/src/xenia/base/filesystem_posix.cc
+++ b/src/xenia/base/filesystem_posix.cc
@@ -7,6 +7,7 @@
  ******************************************************************************
  */
 
+#include "xenia/base/assert.h"
 #include "xenia/base/filesystem.h"
 #include "xenia/base/logging.h"
 #include "xenia/base/string.h"
@@ -21,6 +22,21 @@
 namespace xe {
 namespace filesystem {
 
+std::wstring GetExecutablePath() {
+  assert_always();  // IMPLEMENT ME.
+  return std::wstring();
+}
+
+std::wstring GetExecutableFolder() {
+  assert_always();  // IMPLEMENT ME.
+  return std::wstring();
+}
+
+std::wstring GetUserFolder() {
+  assert_always();  // IMPLEMENT ME.
+  return std::wstring();
+}
+
 bool PathExists(const std::wstring& path) {
   struct stat st;
   return stat(xe::to_string(path).c_str(), &st) == 0;
diff --git a/src/xenia/base/filesystem_win.cc b/src/xenia/base/filesystem_win.cc
index c72ebea07..25b0c319d 100644
--- a/src/xenia/base/filesystem_win.cc
+++ b/src/xenia/base/filesystem_win.cc
@@ -12,11 +12,33 @@
 
 #include <string>
 
+#include <shlobj.h>
+
 #include "xenia/base/platform_win.h"
 
 namespace xe {
 namespace filesystem {
 
+std::wstring GetExecutablePath() {
+  wchar_t* path;
+  auto error = _get_wpgmptr(&path);
+  return !error ? std::wstring(path) : std::wstring();
+}
+
+std::wstring GetExecutableFolder() {
+  auto path = GetExecutablePath();
+  return xe::find_base_path(path);
+}
+
+std::wstring GetUserFolder() {
+  wchar_t path[MAX_PATH];
+  if (!SUCCEEDED(SHGetFolderPathW(nullptr, CSIDL_MYDOCUMENTS, nullptr,
+                                  SHGFP_TYPE_CURRENT, path))) {
+    return std::wstring();
+  }
+  return std::wstring(path);
+}
+
 bool PathExists(const std::wstring& path) {
   DWORD attrib = GetFileAttributes(path.c_str());
   return attrib != INVALID_FILE_ATTRIBUTES;
diff --git a/src/xenia/base/logging.cc b/src/xenia/base/logging.cc
index 72b04a1f8..10f3065d5 100644
--- a/src/xenia/base/logging.cc
+++ b/src/xenia/base/logging.cc
@@ -156,9 +156,12 @@ class Logger {
   void WriteThread() {
     RingBuffer rb(buffer_, kBufferSize);
     uint32_t idle_loops = 0;
-    while (running_) {
+    while (true) {
       bool did_write = false;
       rb.set_write_offset(write_tail_);
+      if (!running_ && rb.empty()) {
+        break;
+      }
       while (!rb.empty()) {
         did_write = true;
 
diff --git a/src/xenia/base/main_win.cc b/src/xenia/base/main_win.cc
index b8047d280..e495b07d8 100644
--- a/src/xenia/base/main_win.cc
+++ b/src/xenia/base/main_win.cc
@@ -22,6 +22,8 @@
 #include "xenia/base/platform_win.h"
 #include "xenia/base/string.h"
 
+#include "third_party/xbyak/xbyak/xbyak_util.h"
+
 #include <bcrypt.h>
 
 DEFINE_bool(win32_high_freq, true,
@@ -85,11 +87,6 @@ static void RequestHighPerformance() {
 int Main() {
   auto entry_info = xe::GetEntryInfo();
 
-  // Request high performance timing.
-  if (FLAGS_win32_high_freq) {
-    RequestHighPerformance();
-  }
-
   // Convert command line to an argv-like format so we can share code/use
   // gflags.
   auto command_line = GetCommandLineW();
@@ -132,10 +129,23 @@ int Main() {
   // Initialize logging. Needs parsed FLAGS.
   xe::InitializeLogging(entry_info.name);
 
+  Xbyak::util::Cpu cpu;
+  if (!cpu.has(Xbyak::util::Cpu::tAVX)) {
+    xe::FatalError(
+        "Your CPU does not support AVX, which is required by Xenia. See the "
+        "FAQ for system requirements at https://xenia.jp");
+    return -1;
+  }
+
   // Print version info.
   XELOGI("Build: %s / %s on %s", XE_BUILD_BRANCH, XE_BUILD_COMMIT,
          XE_BUILD_DATE);
 
+  // Request high performance timing.
+  if (FLAGS_win32_high_freq) {
+    RequestHighPerformance();
+  }
+
   // Call app-provided entry point.
   int result = entry_info.entry_point(args);
 
diff --git a/src/xenia/base/memory.cc b/src/xenia/base/memory.cc
index 1f9d654a1..f7e70d2ff 100644
--- a/src/xenia/base/memory.cc
+++ b/src/xenia/base/memory.cc
@@ -15,9 +15,13 @@
 namespace xe {
 
 // TODO(benvanik): fancy AVX versions.
-// http://gnuradio.org/redmine/projects/gnuradio/repository/revisions/cb32b70b79f430456208a2cd521d028e0ece5d5b/entry/volk/kernels/volk/volk_16u_byteswap.h
-// http://gnuradio.org/redmine/projects/gnuradio/repository/revisions/f2bc76cc65ffba51a141950f98e75364e49df874/entry/volk/kernels/volk/volk_32u_byteswap.h
-// http://gnuradio.org/redmine/projects/gnuradio/repository/revisions/2c4c371885c31222362f70a1cd714415d1398021/entry/volk/kernels/volk/volk_64u_byteswap.h
+// https://github.com/gnuradio/volk/blob/master/kernels/volk/volk_16u_byteswap.h
+// https://github.com/gnuradio/volk/blob/master/kernels/volk/volk_32u_byteswap.h
+// https://github.com/gnuradio/volk/blob/master/kernels/volk/volk_64u_byteswap.h
+// Original links:
+// https://gnuradio.org/redmine/projects/gnuradio/repository/revisions/cb32b70b79f430456208a2cd521d028e0ece5d5b/entry/volk/kernels/volk/volk_16u_byteswap.h
+// https://gnuradio.org/redmine/projects/gnuradio/repository/revisions/f2bc76cc65ffba51a141950f98e75364e49df874/entry/volk/kernels/volk/volk_32u_byteswap.h
+// https://gnuradio.org/redmine/projects/gnuradio/repository/revisions/2c4c371885c31222362f70a1cd714415d1398021/entry/volk/kernels/volk/volk_64u_byteswap.h
 
 void copy_128_aligned(void* dest, const void* src, size_t count) {
   std::memcpy(dest, src, count * 16);
diff --git a/src/xenia/base/platform.h b/src/xenia/base/platform.h
index 0e0c6919d..55b8c59e7 100644
--- a/src/xenia/base/platform.h
+++ b/src/xenia/base/platform.h
@@ -19,7 +19,9 @@
 // NOTE: ordering matters here as sometimes multiple flags are defined on
 // certain platforms.
 //
-// Great resource on predefined macros: http://predef.sourceforge.net/preos.html
+// Great resource on predefined macros:
+// https://sourceforge.net/p/predef/wiki/OperatingSystems/
+// Original link: https://predef.sourceforge.net/preos.html
 
 #if defined(__APPLE__)
 #include <TargetConditionals.h>
diff --git a/src/xenia/base/profiling.cc b/src/xenia/base/profiling.cc
index 073adaa82..e40ce177d 100644
--- a/src/xenia/base/profiling.cc
+++ b/src/xenia/base/profiling.cc
@@ -114,7 +114,7 @@ void Profiler::ThreadEnter(const char* name) {
 void Profiler::ThreadExit() { MicroProfileOnThreadExit(); }
 
 bool Profiler::OnKeyDown(int key_code) {
-  // http://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
+  // https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
   switch (key_code) {
     case VK_OEM_3:  // `
       MicroProfileTogglePause();
diff --git a/src/xenia/base/string_buffer.cc b/src/xenia/base/string_buffer.cc
index d85bb411a..f7b4c8889 100644
--- a/src/xenia/base/string_buffer.cc
+++ b/src/xenia/base/string_buffer.cc
@@ -27,7 +27,10 @@ StringBuffer::~StringBuffer() {
   buffer_ = nullptr;
 }
 
-void StringBuffer::Reset() { buffer_offset_ = 0; }
+void StringBuffer::Reset() {
+  buffer_offset_ = 0;
+  buffer_[0] = 0;
+}
 
 void StringBuffer::Grow(size_t additional_length) {
   if (buffer_offset_ + additional_length <= buffer_capacity_) {
diff --git a/src/xenia/base/threading_win.cc b/src/xenia/base/threading_win.cc
index 4381db8cb..bbdd03624 100644
--- a/src/xenia/base/threading_win.cc
+++ b/src/xenia/base/threading_win.cc
@@ -29,7 +29,7 @@ uint32_t current_thread_system_id() {
   return static_cast<uint32_t>(GetCurrentThreadId());
 }
 
-// http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
+// https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
 #pragma pack(push, 8)
 struct THREADNAME_INFO {
   DWORD dwType;      // Must be 0x1000.
diff --git a/src/xenia/cpu/backend/x64/x64_backend.cc b/src/xenia/cpu/backend/x64/x64_backend.cc
index 3390869e5..4e6356959 100644
--- a/src/xenia/cpu/backend/x64/x64_backend.cc
+++ b/src/xenia/cpu/backend/x64/x64_backend.cc
@@ -42,6 +42,15 @@ class X64ThunkEmitter : public X64Emitter {
   HostToGuestThunk EmitHostToGuestThunk();
   GuestToHostThunk EmitGuestToHostThunk();
   ResolveFunctionThunk EmitResolveFunctionThunk();
+
+ private:
+  // The following four functions provide save/load functionality for registers.
+  // They assume at least StackLayout::THUNK_STACK_SIZE bytes have been
+  // allocated on the stack.
+  void EmitSaveVolatileRegs();
+  void EmitLoadVolatileRegs();
+  void EmitSaveNonvolatileRegs();
+  void EmitLoadNonvolatileRegs();
 };
 
 X64Backend::X64Backend() : Backend(), code_cache_(nullptr) {
@@ -73,8 +82,6 @@ bool X64Backend::Initialize(Processor* processor) {
     return false;
   }
 
-  RegisterSequences();
-
   // Need movbe to do advanced LOAD/STORE tricks.
   if (FLAGS_enable_haswell_instructions) {
     machine_info_.supports_extended_load_store =
@@ -187,7 +194,7 @@ uint64_t ReadCapstoneReg(X64Context* context, x86_reg reg) {
 #define X86_EFLAGS_SF 0x00000080  // Sign Flag
 #define X86_EFLAGS_OF 0x00000800  // Overflow Flag
 bool TestCapstoneEflags(uint32_t eflags, uint32_t insn) {
-  // http://www.felixcloutier.com/x86/Jcc.html
+  // https://www.felixcloutier.com/x86/Jcc.html
   switch (insn) {
     case X86_INS_JAE:
       // CF=0 && ZF=0
@@ -406,6 +413,117 @@ HostToGuestThunk X64ThunkEmitter::EmitHostToGuestThunk() {
   mov(qword[rsp + 8 * 1], rcx);
   sub(rsp, stack_size);
 
+  // Save nonvolatile registers.
+  EmitSaveNonvolatileRegs();
+
+  mov(rax, rcx);
+  mov(rsi, rdx);  // context
+  mov(rcx, r8);   // return address
+  call(rax);
+
+  EmitLoadNonvolatileRegs();
+
+  add(rsp, stack_size);
+  mov(rcx, qword[rsp + 8 * 1]);
+  mov(rdx, qword[rsp + 8 * 2]);
+  mov(r8, qword[rsp + 8 * 3]);
+  ret();
+
+  void* fn = Emplace(stack_size);
+  return (HostToGuestThunk)fn;
+}
+
+GuestToHostThunk X64ThunkEmitter::EmitGuestToHostThunk() {
+  // rcx = target function
+  // rdx = arg0
+  // r8  = arg1
+  // r9  = arg2
+
+  const size_t stack_size = StackLayout::THUNK_STACK_SIZE;
+  // rsp + 0 = return address
+  sub(rsp, stack_size);
+
+  // Save off volatile registers.
+  EmitSaveVolatileRegs();
+
+  mov(rax, rcx);              // function
+  mov(rcx, GetContextReg());  // context
+  call(rax);
+
+  EmitLoadVolatileRegs();
+
+  add(rsp, stack_size);
+  ret();
+
+  void* fn = Emplace(stack_size);
+  return (GuestToHostThunk)fn;
+}
+
+// X64Emitter handles actually resolving functions.
+extern "C" uint64_t ResolveFunction(void* raw_context, uint32_t target_address);
+
+ResolveFunctionThunk X64ThunkEmitter::EmitResolveFunctionThunk() {
+  // ebx = target PPC address
+  // rcx = context
+  const size_t stack_size = StackLayout::THUNK_STACK_SIZE;
+
+  // rsp + 0 = return address
+  sub(rsp, stack_size);
+
+  // Save volatile registers
+  EmitSaveVolatileRegs();
+
+  mov(rcx, rsi);  // context
+  mov(rdx, rbx);
+  mov(rax, uint64_t(&ResolveFunction));
+  call(rax);
+
+  EmitLoadVolatileRegs();
+
+  add(rsp, stack_size);
+  jmp(rax);
+
+  void* fn = Emplace(stack_size);
+  return (ResolveFunctionThunk)fn;
+}
+
+void X64ThunkEmitter::EmitSaveVolatileRegs() {
+  // Save off volatile registers.
+  // mov(qword[rsp + offsetof(StackLayout::Thunk, r[0])], rax);
+  mov(qword[rsp + offsetof(StackLayout::Thunk, r[1])], rcx);
+  mov(qword[rsp + offsetof(StackLayout::Thunk, r[2])], rdx);
+  mov(qword[rsp + offsetof(StackLayout::Thunk, r[3])], r8);
+  mov(qword[rsp + offsetof(StackLayout::Thunk, r[4])], r9);
+  mov(qword[rsp + offsetof(StackLayout::Thunk, r[5])], r10);
+  mov(qword[rsp + offsetof(StackLayout::Thunk, r[6])], r11);
+
+  // movaps(qword[rsp + offsetof(StackLayout::Thunk, xmm[0])], xmm0);
+  movaps(qword[rsp + offsetof(StackLayout::Thunk, xmm[1])], xmm1);
+  movaps(qword[rsp + offsetof(StackLayout::Thunk, xmm[2])], xmm2);
+  movaps(qword[rsp + offsetof(StackLayout::Thunk, xmm[3])], xmm3);
+  movaps(qword[rsp + offsetof(StackLayout::Thunk, xmm[4])], xmm4);
+  movaps(qword[rsp + offsetof(StackLayout::Thunk, xmm[5])], xmm5);
+}
+
+void X64ThunkEmitter::EmitLoadVolatileRegs() {
+  // Load volatile registers from our stack frame.
+  // movaps(xmm0, qword[rsp + offsetof(StackLayout::Thunk, xmm[0])]);
+  movaps(xmm1, qword[rsp + offsetof(StackLayout::Thunk, xmm[1])]);
+  movaps(xmm2, qword[rsp + offsetof(StackLayout::Thunk, xmm[2])]);
+  movaps(xmm3, qword[rsp + offsetof(StackLayout::Thunk, xmm[3])]);
+  movaps(xmm4, qword[rsp + offsetof(StackLayout::Thunk, xmm[4])]);
+  movaps(xmm5, qword[rsp + offsetof(StackLayout::Thunk, xmm[5])]);
+
+  // mov(rax, qword[rsp + offsetof(StackLayout::Thunk, r[0])]);
+  mov(rcx, qword[rsp + offsetof(StackLayout::Thunk, r[1])]);
+  mov(rdx, qword[rsp + offsetof(StackLayout::Thunk, r[2])]);
+  mov(r8, qword[rsp + offsetof(StackLayout::Thunk, r[3])]);
+  mov(r9, qword[rsp + offsetof(StackLayout::Thunk, r[4])]);
+  mov(r10, qword[rsp + offsetof(StackLayout::Thunk, r[5])]);
+  mov(r11, qword[rsp + offsetof(StackLayout::Thunk, r[6])]);
+}
+
+void X64ThunkEmitter::EmitSaveNonvolatileRegs() {
   // Preserve nonvolatile registers.
   mov(qword[rsp + offsetof(StackLayout::Thunk, r[0])], rbx);
   mov(qword[rsp + offsetof(StackLayout::Thunk, r[1])], rcx);
@@ -427,12 +545,9 @@ HostToGuestThunk X64ThunkEmitter::EmitHostToGuestThunk() {
   movaps(qword[rsp + offsetof(StackLayout::Thunk, xmm[7])], xmm13);
   movaps(qword[rsp + offsetof(StackLayout::Thunk, xmm[8])], xmm14);
   movaps(qword[rsp + offsetof(StackLayout::Thunk, xmm[9])], xmm15);
+}
 
-  mov(rax, rcx);
-  mov(rsi, rdx);  // context
-  mov(rcx, r8);   // return address
-  call(rax);
-
+void X64ThunkEmitter::EmitLoadNonvolatileRegs() {
   movaps(xmm6, qword[rsp + offsetof(StackLayout::Thunk, xmm[0])]);
   movaps(xmm7, qword[rsp + offsetof(StackLayout::Thunk, xmm[1])]);
   movaps(xmm8, qword[rsp + offsetof(StackLayout::Thunk, xmm[2])]);
@@ -453,100 +568,6 @@ HostToGuestThunk X64ThunkEmitter::EmitHostToGuestThunk() {
   mov(r13, qword[rsp + offsetof(StackLayout::Thunk, r[6])]);
   mov(r14, qword[rsp + offsetof(StackLayout::Thunk, r[7])]);
   mov(r15, qword[rsp + offsetof(StackLayout::Thunk, r[8])]);
-
-  add(rsp, stack_size);
-  mov(rcx, qword[rsp + 8 * 1]);
-  mov(rdx, qword[rsp + 8 * 2]);
-  mov(r8, qword[rsp + 8 * 3]);
-  ret();
-
-  void* fn = Emplace(stack_size);
-  return (HostToGuestThunk)fn;
-}
-
-GuestToHostThunk X64ThunkEmitter::EmitGuestToHostThunk() {
-  // rcx = context
-  // rdx = target function
-  // r8  = arg0
-  // r9  = arg1
-  // r10 = arg2
-
-  const size_t stack_size = StackLayout::THUNK_STACK_SIZE;
-  // rsp + 0 = return address
-  mov(qword[rsp + 8 * 2], rdx);
-  mov(qword[rsp + 8 * 1], rcx);
-  sub(rsp, stack_size);
-
-  // Save off volatile registers.
-  // TODO(DrChat): Enable this when we actually need this.
-  // mov(qword[rsp + offsetof(StackLayout::Thunk, r[0])], rcx);
-  // mov(qword[rsp + offsetof(StackLayout::Thunk, r[1])], rdx);
-  // mov(qword[rsp + offsetof(StackLayout::Thunk, r[2])], r8);
-  // mov(qword[rsp + offsetof(StackLayout::Thunk, r[3])], r9);
-  // mov(qword[rsp + offsetof(StackLayout::Thunk, r[4])], r10);
-  // mov(qword[rsp + offsetof(StackLayout::Thunk, r[5])], r11);
-
-  // movaps(qword[rsp + offsetof(StackLayout::Thunk, xmm[1])], xmm1);
-  // movaps(qword[rsp + offsetof(StackLayout::Thunk, xmm[2])], xmm2);
-  // movaps(qword[rsp + offsetof(StackLayout::Thunk, xmm[3])], xmm3);
-  // movaps(qword[rsp + offsetof(StackLayout::Thunk, xmm[4])], xmm4);
-  // movaps(qword[rsp + offsetof(StackLayout::Thunk, xmm[5])], xmm5);
-
-  mov(rax, rdx);
-  mov(rcx, rsi);  // context
-  mov(rdx, r8);
-  mov(r8, r9);
-  mov(r9, r10);
-  call(rax);
-
-  // movaps(xmm1, qword[rsp + offsetof(StackLayout::Thunk, xmm[1])]);
-  // movaps(xmm2, qword[rsp + offsetof(StackLayout::Thunk, xmm[2])]);
-  // movaps(xmm3, qword[rsp + offsetof(StackLayout::Thunk, xmm[3])]);
-  // movaps(xmm4, qword[rsp + offsetof(StackLayout::Thunk, xmm[4])]);
-  // movaps(xmm5, qword[rsp + offsetof(StackLayout::Thunk, xmm[5])]);
-
-  // mov(rcx, qword[rsp + offsetof(StackLayout::Thunk, r[0])]);
-  // mov(rdx, qword[rsp + offsetof(StackLayout::Thunk, r[1])]);
-  // mov(r8, qword[rsp + offsetof(StackLayout::Thunk, r[2])]);
-  // mov(r9, qword[rsp + offsetof(StackLayout::Thunk, r[3])]);
-  // mov(r10, qword[rsp + offsetof(StackLayout::Thunk, r[4])]);
-  // mov(r11, qword[rsp + offsetof(StackLayout::Thunk, r[5])]);
-
-  add(rsp, stack_size);
-  mov(rcx, qword[rsp + 8 * 1]);
-  mov(rdx, qword[rsp + 8 * 2]);
-  ret();
-
-  void* fn = Emplace(stack_size);
-  return (GuestToHostThunk)fn;
-}
-
-// X64Emitter handles actually resolving functions.
-extern "C" uint64_t ResolveFunction(void* raw_context, uint32_t target_address);
-
-ResolveFunctionThunk X64ThunkEmitter::EmitResolveFunctionThunk() {
-  // ebx = target PPC address
-  // rcx = context
-
-  uint32_t stack_size = 0x18;
-
-  // rsp + 0 = return address
-  mov(qword[rsp + 8 * 2], rdx);
-  mov(qword[rsp + 8 * 1], rcx);
-  sub(rsp, stack_size);
-
-  mov(rcx, rsi);  // context
-  mov(rdx, rbx);
-  mov(rax, uint64_t(&ResolveFunction));
-  call(rax);
-
-  add(rsp, stack_size);
-  mov(rcx, qword[rsp + 8 * 1]);
-  mov(rdx, qword[rsp + 8 * 2]);
-  jmp(rax);
-
-  void* fn = Emplace(stack_size);
-  return (ResolveFunctionThunk)fn;
 }
 
 }  // namespace x64
diff --git a/src/xenia/cpu/backend/x64/x64_code_cache.cc b/src/xenia/cpu/backend/x64/x64_code_cache.cc
index ac05fe3e9..e4a23248e 100644
--- a/src/xenia/cpu/backend/x64/x64_code_cache.cc
+++ b/src/xenia/cpu/backend/x64/x64_code_cache.cc
@@ -174,22 +174,25 @@ void* X64CodeCache::PlaceGuestCode(uint32_t guest_address, void* machine_code,
     // If we are going above the high water mark of committed memory, commit
     // some more. It's ok if multiple threads do this, as redundant commits
     // aren't harmful.
-    size_t old_commit_mark = generated_code_commit_mark_;
-    if (high_mark > old_commit_mark) {
-      size_t new_commit_mark = old_commit_mark + 16 * 1024 * 1024;
+    size_t old_commit_mark, new_commit_mark;
+    do {
+      old_commit_mark = generated_code_commit_mark_;
+      if (high_mark <= old_commit_mark) break;
+
+      new_commit_mark = old_commit_mark + 16 * 1024 * 1024;
       xe::memory::AllocFixed(generated_code_base_, new_commit_mark,
                              xe::memory::AllocationType::kCommit,
                              xe::memory::PageAccess::kExecuteReadWrite);
-      generated_code_commit_mark_.compare_exchange_strong(old_commit_mark,
-                                                          new_commit_mark);
-    }
+    } while (generated_code_commit_mark_.compare_exchange_weak(
+        old_commit_mark, new_commit_mark));
 
     // Copy code.
     std::memcpy(code_address, machine_code, code_size);
 
     // Fill unused slots with 0xCC
-    std::memset(code_address + code_size, 0xCC,
-                xe::round_up(code_size, 16) - code_size);
+    std::memset(
+        code_address + code_size, 0xCC,
+        xe::round_up(code_size + unwind_reservation.data_size, 16) - code_size);
 
     // Notify subclasses of placed code.
     PlaceCode(guest_address, machine_code, code_size, stack_size, code_address,
@@ -247,15 +250,17 @@ uint32_t X64CodeCache::PlaceData(const void* data, size_t length) {
   // If we are going above the high water mark of committed memory, commit some
   // more. It's ok if multiple threads do this, as redundant commits aren't
   // harmful.
-  size_t old_commit_mark = generated_code_commit_mark_;
-  if (high_mark > old_commit_mark) {
-    size_t new_commit_mark = old_commit_mark + 16 * 1024 * 1024;
+  size_t old_commit_mark, new_commit_mark;
+  do {
+    old_commit_mark = generated_code_commit_mark_;
+    if (high_mark <= old_commit_mark) break;
+
+    new_commit_mark = old_commit_mark + 16 * 1024 * 1024;
     xe::memory::AllocFixed(generated_code_base_, new_commit_mark,
                            xe::memory::AllocationType::kCommit,
                            xe::memory::PageAccess::kExecuteReadWrite);
-    generated_code_commit_mark_.compare_exchange_strong(old_commit_mark,
-                                                        new_commit_mark);
-  }
+  } while (generated_code_commit_mark_.compare_exchange_weak(old_commit_mark,
+                                                             new_commit_mark));
 
   // Copy code.
   std::memcpy(data_address, data, length);
diff --git a/src/xenia/cpu/backend/x64/x64_code_cache_win.cc b/src/xenia/cpu/backend/x64/x64_code_cache_win.cc
index 1c6eecee0..5a0fb2d4e 100644
--- a/src/xenia/cpu/backend/x64/x64_code_cache_win.cc
+++ b/src/xenia/cpu/backend/x64/x64_code_cache_win.cc
@@ -20,137 +20,24 @@
 #include "xenia/base/platform_win.h"
 #include "xenia/cpu/function.h"
 
-// When enabled, this will use Windows 8 APIs to get unwind info.
-// TODO(benvanik): figure out why the callback variant doesn't work.
-#define USE_GROWABLE_FUNCTION_TABLE
+// Function pointer definitions
+typedef DWORD(NTAPI* FnRtlAddGrowableFunctionTable)(
+    _Out_ PVOID* DynamicTable,
+    _In_reads_(MaximumEntryCount) PRUNTIME_FUNCTION FunctionTable,
+    _In_ DWORD EntryCount, _In_ DWORD MaximumEntryCount,
+    _In_ ULONG_PTR RangeBase, _In_ ULONG_PTR RangeEnd);
+
+typedef VOID(NTAPI* FnRtlGrowFunctionTable)(_Inout_ PVOID DynamicTable,
+                                            _In_ DWORD NewEntryCount);
+
+typedef VOID(NTAPI* FnRtlDeleteGrowableFunctionTable)(_In_ PVOID DynamicTable);
 
 namespace xe {
 namespace cpu {
 namespace backend {
 namespace x64 {
 
-// Size of unwind info per function.
-// TODO(benvanik): move this to emitter.
-static const uint32_t kUnwindInfoSize = 4 + (2 * 1 + 2 + 2);
-
-class Win32X64CodeCache : public X64CodeCache {
- public:
-  Win32X64CodeCache();
-  ~Win32X64CodeCache() override;
-
-  bool Initialize() override;
-
-  void* LookupUnwindInfo(uint64_t host_pc) override;
-
- private:
-  UnwindReservation RequestUnwindReservation(uint8_t* entry_address) override;
-  void PlaceCode(uint32_t guest_address, void* machine_code, size_t code_size,
-                 size_t stack_size, void* code_address,
-                 UnwindReservation unwind_reservation) override;
-
-  void InitializeUnwindEntry(uint8_t* unwind_entry_address,
-                             size_t unwind_table_slot, void* code_address,
-                             size_t code_size, size_t stack_size);
-
-  // Growable function table system handle.
-  void* unwind_table_handle_ = nullptr;
-  // Actual unwind table entries.
-  std::vector<RUNTIME_FUNCTION> unwind_table_;
-  // Current number of entries in the table.
-  std::atomic<uint32_t> unwind_table_count_ = {0};
-};
-
-std::unique_ptr<X64CodeCache> X64CodeCache::Create() {
-  return std::make_unique<Win32X64CodeCache>();
-}
-
-Win32X64CodeCache::Win32X64CodeCache() = default;
-
-Win32X64CodeCache::~Win32X64CodeCache() {
-#ifdef USE_GROWABLE_FUNCTION_TABLE
-  if (unwind_table_handle_) {
-    RtlDeleteGrowableFunctionTable(unwind_table_handle_);
-  }
-#else
-  if (generated_code_base_) {
-    RtlDeleteFunctionTable(reinterpret_cast<PRUNTIME_FUNCTION>(
-        reinterpret_cast<DWORD64>(generated_code_base_) | 0x3));
-  }
-#endif  // USE_GROWABLE_FUNCTION_TABLE
-}
-
-bool Win32X64CodeCache::Initialize() {
-  if (!X64CodeCache::Initialize()) {
-    return false;
-  }
-
-  // Compute total number of unwind entries we should allocate.
-  // We don't support reallocing right now, so this should be high.
-  unwind_table_.resize(kMaximumFunctionCount);
-
-#ifdef USE_GROWABLE_FUNCTION_TABLE
-  // Create table and register with the system. It's empty now, but we'll grow
-  // it as functions are added.
-  if (RtlAddGrowableFunctionTable(
-          &unwind_table_handle_, unwind_table_.data(), unwind_table_count_,
-          DWORD(unwind_table_.size()),
-          reinterpret_cast<ULONG_PTR>(generated_code_base_),
-          reinterpret_cast<ULONG_PTR>(generated_code_base_ +
-                                      kGeneratedCodeSize))) {
-    XELOGE("Unable to create unwind function table");
-    return false;
-  }
-#else
-  // Install a callback that the debugger will use to lookup unwind info on
-  // demand.
-  if (!RtlInstallFunctionTableCallback(
-          reinterpret_cast<DWORD64>(generated_code_base_) | 0x3,
-          reinterpret_cast<DWORD64>(generated_code_base_), kGeneratedCodeSize,
-          [](uintptr_t control_pc, void* context) {
-            auto code_cache = reinterpret_cast<X64CodeCache*>(context);
-            return reinterpret_cast<PRUNTIME_FUNCTION>(
-                code_cache->LookupUnwindEntry(control_pc));
-          },
-          this, nullptr)) {
-    XELOGE("Unable to install function table callback");
-    return false;
-  }
-#endif  // USE_GROWABLE_FUNCTION_TABLE
-
-  return true;
-}
-
-Win32X64CodeCache::UnwindReservation
-Win32X64CodeCache::RequestUnwindReservation(uint8_t* entry_address) {
-  UnwindReservation unwind_reservation;
-  unwind_reservation.data_size = xe::round_up(kUnwindInfoSize, 16);
-  unwind_reservation.table_slot = ++unwind_table_count_;
-  unwind_reservation.entry_address = entry_address;
-  assert_false(unwind_table_count_ >= kMaximumFunctionCount);
-
-  return unwind_reservation;
-}
-
-void Win32X64CodeCache::PlaceCode(uint32_t guest_address, void* machine_code,
-                                  size_t code_size, size_t stack_size,
-                                  void* code_address,
-                                  UnwindReservation unwind_reservation) {
-  // Add unwind info.
-  InitializeUnwindEntry(unwind_reservation.entry_address,
-                        unwind_reservation.table_slot, code_address, code_size,
-                        stack_size);
-
-#ifdef USE_GROWABLE_FUNCTION_TABLE
-  // Notify that the unwind table has grown.
-  // We do this outside of the lock, but with the latest total count.
-  RtlGrowFunctionTable(unwind_table_handle_, unwind_table_count_);
-#endif  // USE_GROWABLE_FUNCTION_TABLE
-
-  // This isn't needed on x64 (probably), but is convention.
-  FlushInstructionCache(GetCurrentProcess(), code_address, code_size);
-}
-
-// http://msdn.microsoft.com/en-us/library/ssa62fwe.aspx
+// https://msdn.microsoft.com/en-us/library/ssa62fwe.aspx
 typedef enum _UNWIND_OP_CODES {
   UWOP_PUSH_NONVOL = 0, /* info == register number */
   UWOP_ALLOC_LARGE,     /* no info, alloc size in next 2 slots */
@@ -209,15 +96,153 @@ typedef struct _UNWIND_INFO {
    *   OPTIONAL ULONG ExceptionData[]; */
 } UNWIND_INFO, *PUNWIND_INFO;
 
+// Size of unwind info per function.
+// TODO(benvanik): move this to emitter.
+static const uint32_t kUnwindInfoSize =
+    sizeof(UNWIND_INFO) + (sizeof(UNWIND_CODE) * (6 - 1));
+
+class Win32X64CodeCache : public X64CodeCache {
+ public:
+  Win32X64CodeCache();
+  ~Win32X64CodeCache() override;
+
+  bool Initialize() override;
+
+  void* LookupUnwindInfo(uint64_t host_pc) override;
+
+ private:
+  UnwindReservation RequestUnwindReservation(uint8_t* entry_address) override;
+  void PlaceCode(uint32_t guest_address, void* machine_code, size_t code_size,
+                 size_t stack_size, void* code_address,
+                 UnwindReservation unwind_reservation) override;
+
+  void InitializeUnwindEntry(uint8_t* unwind_entry_address,
+                             size_t unwind_table_slot, void* code_address,
+                             size_t code_size, size_t stack_size);
+
+  // Growable function table system handle.
+  void* unwind_table_handle_ = nullptr;
+  // Actual unwind table entries.
+  std::vector<RUNTIME_FUNCTION> unwind_table_;
+  // Current number of entries in the table.
+  std::atomic<uint32_t> unwind_table_count_ = {0};
+  // Does this version of Windows support growable funciton tables?
+  bool supports_growable_table_ = false;
+
+  FnRtlAddGrowableFunctionTable add_growable_table_ = nullptr;
+  FnRtlDeleteGrowableFunctionTable delete_growable_table_ = nullptr;
+  FnRtlGrowFunctionTable grow_table_ = nullptr;
+};
+
+std::unique_ptr<X64CodeCache> X64CodeCache::Create() {
+  return std::make_unique<Win32X64CodeCache>();
+}
+
+Win32X64CodeCache::Win32X64CodeCache() = default;
+
+Win32X64CodeCache::~Win32X64CodeCache() {
+  if (supports_growable_table_) {
+    if (unwind_table_handle_) {
+      delete_growable_table_(unwind_table_handle_);
+    }
+  } else {
+    if (generated_code_base_) {
+      RtlDeleteFunctionTable(reinterpret_cast<PRUNTIME_FUNCTION>(
+          reinterpret_cast<DWORD64>(generated_code_base_) | 0x3));
+    }
+  }
+}
+
+bool Win32X64CodeCache::Initialize() {
+  if (!X64CodeCache::Initialize()) {
+    return false;
+  }
+
+  // Compute total number of unwind entries we should allocate.
+  // We don't support reallocing right now, so this should be high.
+  unwind_table_.resize(kMaximumFunctionCount);
+
+  // Check if this version of Windows supports growable function tables.
+  add_growable_table_ = (FnRtlAddGrowableFunctionTable)GetProcAddress(
+      GetModuleHandleW(L"ntdll.dll"), "RtlAddGrowableFunctionTable");
+  delete_growable_table_ = (FnRtlDeleteGrowableFunctionTable)GetProcAddress(
+      GetModuleHandleW(L"ntdll.dll"), "RtlDeleteGrowableFunctionTable");
+  grow_table_ = (FnRtlGrowFunctionTable)GetProcAddress(
+      GetModuleHandleW(L"ntdll.dll"), "RtlGrowFunctionTable");
+  supports_growable_table_ =
+      add_growable_table_ && delete_growable_table_ && grow_table_;
+
+  // Create table and register with the system. It's empty now, but we'll grow
+  // it as functions are added.
+  if (supports_growable_table_) {
+    if (add_growable_table_(&unwind_table_handle_, unwind_table_.data(),
+                            unwind_table_count_, DWORD(unwind_table_.size()),
+                            reinterpret_cast<ULONG_PTR>(generated_code_base_),
+                            reinterpret_cast<ULONG_PTR>(generated_code_base_ +
+                                                        kGeneratedCodeSize))) {
+      XELOGE("Unable to create unwind function table");
+      return false;
+    }
+  } else {
+    // Install a callback that the debugger will use to lookup unwind info on
+    // demand.
+    if (!RtlInstallFunctionTableCallback(
+            reinterpret_cast<DWORD64>(generated_code_base_) | 0x3,
+            reinterpret_cast<DWORD64>(generated_code_base_), kGeneratedCodeSize,
+            [](DWORD64 control_pc, PVOID context) {
+              auto code_cache = reinterpret_cast<Win32X64CodeCache*>(context);
+              return reinterpret_cast<PRUNTIME_FUNCTION>(
+                  code_cache->LookupUnwindInfo(control_pc));
+            },
+            this, nullptr)) {
+      XELOGE("Unable to install function table callback");
+      return false;
+    }
+  }
+
+  return true;
+}
+
+Win32X64CodeCache::UnwindReservation
+Win32X64CodeCache::RequestUnwindReservation(uint8_t* entry_address) {
+  UnwindReservation unwind_reservation;
+  unwind_reservation.data_size = xe::round_up(kUnwindInfoSize, 16);
+  unwind_reservation.table_slot = ++unwind_table_count_;
+  unwind_reservation.entry_address = entry_address;
+  assert_false(unwind_table_count_ >= kMaximumFunctionCount);
+
+  return unwind_reservation;
+}
+
+void Win32X64CodeCache::PlaceCode(uint32_t guest_address, void* machine_code,
+                                  size_t code_size, size_t stack_size,
+                                  void* code_address,
+                                  UnwindReservation unwind_reservation) {
+  // Add unwind info.
+  InitializeUnwindEntry(unwind_reservation.entry_address,
+                        unwind_reservation.table_slot, code_address, code_size,
+                        stack_size);
+
+  if (supports_growable_table_) {
+    // Notify that the unwind table has grown.
+    // We do this outside of the lock, but with the latest total count.
+    grow_table_(unwind_table_handle_, unwind_table_count_);
+  }
+
+  // This isn't needed on x64 (probably), but is convention.
+  FlushInstructionCache(GetCurrentProcess(), code_address, code_size);
+}
+
 void Win32X64CodeCache::InitializeUnwindEntry(uint8_t* unwind_entry_address,
                                               size_t unwind_table_slot,
                                               void* code_address,
                                               size_t code_size,
                                               size_t stack_size) {
   auto unwind_info = reinterpret_cast<UNWIND_INFO*>(unwind_entry_address);
+  UNWIND_CODE* unwind_code = nullptr;
 
   if (!stack_size) {
-    // http://msdn.microsoft.com/en-us/library/ddssxxy8.aspx
+    // https://msdn.microsoft.com/en-us/library/ddssxxy8.aspx
     unwind_info->Version = 1;
     unwind_info->Flags = 0;
     unwind_info->SizeOfProlog = 0;
@@ -227,44 +252,48 @@ void Win32X64CodeCache::InitializeUnwindEntry(uint8_t* unwind_entry_address,
   } else if (stack_size <= 128) {
     uint8_t prolog_size = 4;
 
-    // http://msdn.microsoft.com/en-us/library/ddssxxy8.aspx
+    // https://msdn.microsoft.com/en-us/library/ddssxxy8.aspx
     unwind_info->Version = 1;
     unwind_info->Flags = 0;
     unwind_info->SizeOfProlog = prolog_size;
-    unwind_info->CountOfCodes = 1;
+    unwind_info->CountOfCodes = 0;
     unwind_info->FrameRegister = 0;
     unwind_info->FrameOffset = 0;
 
-    // http://msdn.microsoft.com/en-us/library/ck9asaa9.aspx
-    size_t co = 0;
-    auto& unwind_code = unwind_info->UnwindCode[co++];
-    unwind_code.CodeOffset =
+    // https://msdn.microsoft.com/en-us/library/ck9asaa9.aspx
+    unwind_code = &unwind_info->UnwindCode[unwind_info->CountOfCodes++];
+    unwind_code->CodeOffset =
         14;  // end of instruction + 1 == offset of next instruction
-    unwind_code.UnwindOp = UWOP_ALLOC_SMALL;
-    unwind_code.OpInfo = stack_size / 8 - 1;
+    unwind_code->UnwindOp = UWOP_ALLOC_SMALL;
+    unwind_code->OpInfo = stack_size / 8 - 1;
   } else {
     // TODO(benvanik): take as parameters?
     uint8_t prolog_size = 7;
 
-    // http://msdn.microsoft.com/en-us/library/ddssxxy8.aspx
+    // https://msdn.microsoft.com/en-us/library/ddssxxy8.aspx
     unwind_info->Version = 1;
     unwind_info->Flags = 0;
     unwind_info->SizeOfProlog = prolog_size;
-    unwind_info->CountOfCodes = 2;
+    unwind_info->CountOfCodes = 0;
     unwind_info->FrameRegister = 0;
     unwind_info->FrameOffset = 0;
 
-    // http://msdn.microsoft.com/en-us/library/ck9asaa9.aspx
-    size_t co = 0;
-    auto& unwind_code = unwind_info->UnwindCode[co++];
-    unwind_code.CodeOffset =
+    // https://msdn.microsoft.com/en-us/library/ck9asaa9.aspx
+    unwind_code = &unwind_info->UnwindCode[unwind_info->CountOfCodes++];
+    unwind_code->CodeOffset =
         7;  // end of instruction + 1 == offset of next instruction
-    unwind_code.UnwindOp = UWOP_ALLOC_LARGE;
-    unwind_code.OpInfo = 0;
+    unwind_code->UnwindOp = UWOP_ALLOC_LARGE;
+    unwind_code->OpInfo = 0;  // One slot for size
 
     assert_true((stack_size / 8) < 65536u);
-    unwind_code = unwind_info->UnwindCode[co++];
-    unwind_code.FrameOffset = (USHORT)(stack_size) / 8;
+    unwind_code = &unwind_info->UnwindCode[unwind_info->CountOfCodes++];
+    unwind_code->FrameOffset = (USHORT)(stack_size) / 8;
+  }
+
+  if (unwind_info->CountOfCodes % 1) {
+    // Count of unwind codes must always be even.
+    std::memset(&unwind_info->UnwindCode[unwind_info->CountOfCodes + 1], 0,
+                sizeof(UNWIND_CODE));
   }
 
   // Add entry.
diff --git a/src/xenia/cpu/backend/x64/x64_emitter.cc b/src/xenia/cpu/backend/x64/x64_emitter.cc
index 5642e11d7..9bbea6df7 100644
--- a/src/xenia/cpu/backend/x64/x64_emitter.cc
+++ b/src/xenia/cpu/backend/x64/x64_emitter.cc
@@ -56,12 +56,13 @@ static const size_t kStashOffset = 32;
 // static const size_t kStashOffsetHigh = 32 + 32;
 
 const uint32_t X64Emitter::gpr_reg_map_[X64Emitter::GPR_COUNT] = {
-    Xbyak::Operand::RBX, Xbyak::Operand::R12, Xbyak::Operand::R13,
-    Xbyak::Operand::R14, Xbyak::Operand::R15,
+    Xbyak::Operand::RBX, Xbyak::Operand::R10, Xbyak::Operand::R11,
+    Xbyak::Operand::R12, Xbyak::Operand::R13, Xbyak::Operand::R14,
+    Xbyak::Operand::R15,
 };
 
 const uint32_t X64Emitter::xmm_reg_map_[X64Emitter::XMM_COUNT] = {
-    6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
 };
 
 X64Emitter::X64Emitter(X64Backend* backend, XbyakAllocator* allocator)
@@ -81,8 +82,8 @@ X64Emitter::X64Emitter(X64Backend* backend, XbyakAllocator* allocator)
 
   if (!cpu_.has(Xbyak::util::Cpu::tAVX)) {
     xe::FatalError(
-        "Your CPU is too old to support Xenia. See the FAQ for system "
-        "requirements at http://xenia.jp");
+        "Your CPU does not support AVX, which is required by Xenia. See the "
+        "FAQ for system requirements at https://xenia.jp");
     return;
   }
 }
@@ -148,11 +149,13 @@ bool X64Emitter::Emit(HIRBuilder* builder, size_t* out_stack_size) {
   for (auto it = locals.begin(); it != locals.end(); ++it) {
     auto slot = *it;
     size_t type_size = GetTypeSize(slot->type);
+
     // Align to natural size.
     stack_offset = xe::align(stack_offset, type_size);
     slot->set_constant((uint32_t)stack_offset);
     stack_offset += type_size;
   }
+
   // Ensure 16b alignment.
   stack_offset -= StackLayout::GUEST_STACK_SIZE;
   stack_offset = xe::align(stack_offset, static_cast<size_t>(16));
@@ -160,7 +163,7 @@ bool X64Emitter::Emit(HIRBuilder* builder, size_t* out_stack_size) {
   // Function prolog.
   // Must be 16b aligned.
   // Windows is very strict about the form of this and the epilog:
-  // http://msdn.microsoft.com/en-us/library/tawsa7cb.aspx
+  // https://docs.microsoft.com/en-us/cpp/build/prolog-and-epilog?view=vs-2017
   // IMPORTANT: any changes to the prolog must be kept in sync with
   //     X64CodeCache, which dynamically generates exception information.
   //     Adding or changing anything here must be matched!
@@ -168,6 +171,7 @@ bool X64Emitter::Emit(HIRBuilder* builder, size_t* out_stack_size) {
   assert_true((stack_size + 8) % 16 == 0);
   *out_stack_size = stack_size;
   stack_size_ = stack_size;
+
   sub(rsp, (uint32_t)stack_size);
   mov(qword[rsp + StackLayout::GUEST_CTX_HOME], GetContextReg());
   mov(qword[rsp + StackLayout::GUEST_RET_ADDR], rcx);
@@ -221,6 +225,8 @@ bool X64Emitter::Emit(HIRBuilder* builder, size_t* out_stack_size) {
       const Instr* new_tail = instr;
       if (!SelectSequence(this, instr, &new_tail)) {
         // No sequence found!
+        // NOTE: If you encounter this after adding a new instruction, do a full
+        // rebuild!
         assert_always();
         XELOGE("Unable to process HIR opcode %s", instr->opcode->name);
         break;
@@ -340,13 +346,14 @@ void X64Emitter::UnimplementedInstr(const hir::Instr* i) {
 
 // This is used by the X64ThunkEmitter's ResolveFunctionThunk.
 extern "C" uint64_t ResolveFunction(void* raw_context,
-                                    uint32_t target_address) {
+                                    uint64_t target_address) {
   auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
 
   // TODO(benvanik): required?
   assert_not_zero(target_address);
 
-  auto fn = thread_state->processor()->ResolveFunction(target_address);
+  auto fn =
+      thread_state->processor()->ResolveFunction((uint32_t)target_address);
   assert_not_null(fn);
   auto x64_fn = static_cast<X64Function*>(fn);
   uint64_t addr = reinterpret_cast<uint64_t>(x64_fn->machine_code());
@@ -373,10 +380,7 @@ void X64Emitter::Call(const hir::Instr* instr, GuestFunction* function) {
     // Old-style resolve.
     // Not too important because indirection table is almost always available.
     // TODO: Overwrite the call-site with a straight call.
-    mov(rax, reinterpret_cast<uint64_t>(ResolveFunction));
-    mov(rcx, GetContextReg());
-    mov(rdx, function->address());
-    call(rax);
+    CallNative(&ResolveFunction, function->address());
   }
 
   // Actually jump/call to rax.
@@ -457,16 +461,15 @@ void X64Emitter::CallExtern(const hir::Instr* instr, const Function* function) {
     auto builtin_function = static_cast<const BuiltinFunction*>(function);
     if (builtin_function->handler()) {
       undefined = false;
-      // rcx = context
-      // rdx = target host function
-      // r8  = arg0
-      // r9  = arg1
-      mov(rcx, GetContextReg());
-      mov(rdx, reinterpret_cast<uint64_t>(builtin_function->handler()));
-      mov(r8, reinterpret_cast<uint64_t>(builtin_function->arg0()));
-      mov(r9, reinterpret_cast<uint64_t>(builtin_function->arg1()));
+      // rcx = target function
+      // rdx = arg0
+      // r8  = arg1
+      // r9  = arg2
       auto thunk = backend()->guest_to_host_thunk();
       mov(rax, reinterpret_cast<uint64_t>(thunk));
+      mov(rcx, reinterpret_cast<uint64_t>(builtin_function->handler()));
+      mov(rdx, reinterpret_cast<uint64_t>(builtin_function->arg0()));
+      mov(r8, reinterpret_cast<uint64_t>(builtin_function->arg1()));
       call(rax);
       // rax = host return
     }
@@ -474,13 +477,15 @@ void X64Emitter::CallExtern(const hir::Instr* instr, const Function* function) {
     auto extern_function = static_cast<const GuestFunction*>(function);
     if (extern_function->extern_handler()) {
       undefined = false;
-      // rcx = context
-      // rdx = target host function
-      mov(rcx, GetContextReg());
-      mov(rdx, reinterpret_cast<uint64_t>(extern_function->extern_handler()));
-      mov(r8, qword[GetContextReg() + offsetof(ppc::PPCContext, kernel_state)]);
+      // rcx = target function
+      // rdx = arg0
+      // r8  = arg1
+      // r9  = arg2
       auto thunk = backend()->guest_to_host_thunk();
       mov(rax, reinterpret_cast<uint64_t>(thunk));
+      mov(rcx, reinterpret_cast<uint64_t>(extern_function->extern_handler()));
+      mov(rdx,
+          qword[GetContextReg() + offsetof(ppc::PPCContext, kernel_state)]);
       call(rax);
       // rax = host return
     }
@@ -490,42 +495,30 @@ void X64Emitter::CallExtern(const hir::Instr* instr, const Function* function) {
   }
 }
 
-void X64Emitter::CallNative(void* fn) {
-  mov(rax, reinterpret_cast<uint64_t>(fn));
-  mov(rcx, GetContextReg());
-  call(rax);
-}
+void X64Emitter::CallNative(void* fn) { CallNativeSafe(fn); }
 
 void X64Emitter::CallNative(uint64_t (*fn)(void* raw_context)) {
-  mov(rax, reinterpret_cast<uint64_t>(fn));
-  mov(rcx, GetContextReg());
-  call(rax);
+  CallNativeSafe(reinterpret_cast<void*>(fn));
 }
 
 void X64Emitter::CallNative(uint64_t (*fn)(void* raw_context, uint64_t arg0)) {
-  mov(rax, reinterpret_cast<uint64_t>(fn));
-  mov(rcx, GetContextReg());
-  call(rax);
+  CallNativeSafe(reinterpret_cast<void*>(fn));
 }
 
 void X64Emitter::CallNative(uint64_t (*fn)(void* raw_context, uint64_t arg0),
                             uint64_t arg0) {
-  mov(rax, reinterpret_cast<uint64_t>(fn));
-  mov(rcx, GetContextReg());
-  mov(rdx, arg0);
-  call(rax);
+  mov(GetNativeParam(0), arg0);
+  CallNativeSafe(reinterpret_cast<void*>(fn));
 }
 
 void X64Emitter::CallNativeSafe(void* fn) {
-  // rcx = context
-  // rdx = target function
-  // r8  = arg0
-  // r9  = arg1
-  // r10 = arg2
+  // rcx = target function
+  // rdx = arg0
+  // r8  = arg1
+  // r9  = arg2
   auto thunk = backend()->guest_to_host_thunk();
   mov(rax, reinterpret_cast<uint64_t>(thunk));
-  mov(rcx, GetContextReg());
-  mov(rdx, reinterpret_cast<uint64_t>(fn));
+  mov(rcx, reinterpret_cast<uint64_t>(fn));
   call(rax);
   // rax = host return
 }
@@ -535,6 +528,18 @@ void X64Emitter::SetReturnAddress(uint64_t value) {
   mov(qword[rsp + StackLayout::GUEST_CALL_RET_ADDR], rax);
 }
 
+Xbyak::Reg64 X64Emitter::GetNativeParam(uint32_t param) {
+  if (param == 0)
+    return rdx;
+  else if (param == 1)
+    return r8;
+  else if (param == 2)
+    return r9;
+
+  assert_always();
+  return r9;
+}
+
 // Important: If you change these, you must update the thunks in x64_backend.cc!
 Xbyak::Reg64 X64Emitter::GetContextReg() { return rsi; }
 Xbyak::Reg64 X64Emitter::GetMembaseReg() { return rdi; }
@@ -637,7 +642,7 @@ static const vec128_t xmm_consts[] = {
     /* XMMUnpackFLOAT16_2     */
     vec128i(0x0D0C0F0Eu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu),
     /* XMMPackFLOAT16_4       */
-    vec128i(0xFFFFFFFFu, 0xFFFFFFFFu, 0x05040706u, 0x01000302u),
+    vec128i(0xFFFFFFFFu, 0xFFFFFFFFu, 0x01000302u, 0x05040706u),
     /* XMMUnpackFLOAT16_4     */
     vec128i(0x09080B0Au, 0x0D0C0F0Eu, 0xFFFFFFFFu, 0xFFFFFFFFu),
     /* XMMPackSHORT_Min       */ vec128i(0x403F8001u),
@@ -738,7 +743,7 @@ Xbyak::Address X64Emitter::GetXmmConstPtr(XmmConst id) {
 }
 
 void X64Emitter::LoadConstantXmm(Xbyak::Xmm dest, const vec128_t& v) {
-  // http://www.agner.org/optimize/optimizing_assembly.pdf
+  // https://www.agner.org/optimize/optimizing_assembly.pdf
   // 13.4 Generating constants
   if (!v.low && !v.high) {
     // 0000...
diff --git a/src/xenia/cpu/backend/x64/x64_emitter.h b/src/xenia/cpu/backend/x64/x64_emitter.h
index 33ce2c0a2..a35c2d2b0 100644
--- a/src/xenia/cpu/backend/x64/x64_emitter.h
+++ b/src/xenia/cpu/backend/x64/x64_emitter.h
@@ -139,13 +139,13 @@ class X64Emitter : public Xbyak::CodeGenerator {
             std::vector<SourceMapEntry>* out_source_map);
 
  public:
-  // Reserved:  rsp
+  // Reserved:  rsp, rsi, rdi
   // Scratch:   rax/rcx/rdx
   //            xmm0-2
-  // Available: rbx, r12-r15 (save to get r8-r11, rbp, rsi, rdi?)
-  //            xmm6-xmm15 (save to get xmm3-xmm5)
-  static const int GPR_COUNT = 5;
-  static const int XMM_COUNT = 10;
+  // Available: rbx, r10-r15
+  //            xmm4-xmm15 (save to get xmm3)
+  static const int GPR_COUNT = 7;
+  static const int XMM_COUNT = 12;
 
   static void SetupReg(const hir::Value* v, Xbyak::Reg8& r) {
     auto idx = gpr_reg_map_[v->reg.index];
@@ -187,6 +187,8 @@ class X64Emitter : public Xbyak::CodeGenerator {
   void CallNativeSafe(void* fn);
   void SetReturnAddress(uint64_t value);
 
+  Xbyak::Reg64 GetNativeParam(uint32_t param);
+
   Xbyak::Reg64 GetContextReg();
   Xbyak::Reg64 GetMembaseReg();
   void ReloadContext();
diff --git a/src/xenia/cpu/backend/x64/x64_op.h b/src/xenia/cpu/backend/x64/x64_op.h
new file mode 100644
index 000000000..f71338304
--- /dev/null
+++ b/src/xenia/cpu/backend/x64/x64_op.h
@@ -0,0 +1,629 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2018 Xenia Developers. All rights reserved.                      *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+#ifndef XENIA_CPU_BACKEND_X64_X64_OP_H_
+#define XENIA_CPU_BACKEND_X64_X64_OP_H_
+
+#include "xenia/cpu/backend/x64/x64_emitter.h"
+
+#include "xenia/cpu/hir/instr.h"
+
+namespace xe {
+namespace cpu {
+namespace backend {
+namespace x64 {
+
+// TODO(benvanik): direct usings.
+using namespace xe::cpu;
+using namespace xe::cpu::hir;
+using namespace Xbyak;
+
+// Selects the right byte/word/etc from a vector. We need to flip logical
+// indices (0,1,2,3,4,5,6,7,...) = (3,2,1,0,7,6,5,4,...)
+#define VEC128_B(n) ((n) ^ 0x3)
+#define VEC128_W(n) ((n) ^ 0x1)
+#define VEC128_D(n) (n)
+#define VEC128_F(n) (n)
+
+enum KeyType {
+  KEY_TYPE_X = OPCODE_SIG_TYPE_X,
+  KEY_TYPE_L = OPCODE_SIG_TYPE_L,
+  KEY_TYPE_O = OPCODE_SIG_TYPE_O,
+  KEY_TYPE_S = OPCODE_SIG_TYPE_S,
+  KEY_TYPE_V_I8 = OPCODE_SIG_TYPE_V + INT8_TYPE,
+  KEY_TYPE_V_I16 = OPCODE_SIG_TYPE_V + INT16_TYPE,
+  KEY_TYPE_V_I32 = OPCODE_SIG_TYPE_V + INT32_TYPE,
+  KEY_TYPE_V_I64 = OPCODE_SIG_TYPE_V + INT64_TYPE,
+  KEY_TYPE_V_F32 = OPCODE_SIG_TYPE_V + FLOAT32_TYPE,
+  KEY_TYPE_V_F64 = OPCODE_SIG_TYPE_V + FLOAT64_TYPE,
+  KEY_TYPE_V_V128 = OPCODE_SIG_TYPE_V + VEC128_TYPE,
+};
+
+#pragma pack(push, 1)
+union InstrKey {
+  struct {
+    uint32_t opcode : 8;
+    uint32_t dest : 5;
+    uint32_t src1 : 5;
+    uint32_t src2 : 5;
+    uint32_t src3 : 5;
+    uint32_t reserved : 4;
+  };
+  uint32_t value;
+
+  operator uint32_t() const { return value; }
+
+  InstrKey() : value(0) {}
+  InstrKey(uint32_t v) : value(v) {}
+  InstrKey(const Instr* i) : value(0) {
+    opcode = i->opcode->num;
+    uint32_t sig = i->opcode->signature;
+    dest =
+        GET_OPCODE_SIG_TYPE_DEST(sig) ? OPCODE_SIG_TYPE_V + i->dest->type : 0;
+    src1 = GET_OPCODE_SIG_TYPE_SRC1(sig);
+    if (src1 == OPCODE_SIG_TYPE_V) {
+      src1 += i->src1.value->type;
+    }
+    src2 = GET_OPCODE_SIG_TYPE_SRC2(sig);
+    if (src2 == OPCODE_SIG_TYPE_V) {
+      src2 += i->src2.value->type;
+    }
+    src3 = GET_OPCODE_SIG_TYPE_SRC3(sig);
+    if (src3 == OPCODE_SIG_TYPE_V) {
+      src3 += i->src3.value->type;
+    }
+  }
+
+  template <Opcode OPCODE, KeyType DEST = KEY_TYPE_X, KeyType SRC1 = KEY_TYPE_X,
+            KeyType SRC2 = KEY_TYPE_X, KeyType SRC3 = KEY_TYPE_X>
+  struct Construct {
+    static const uint32_t value =
+        (OPCODE) | (DEST << 8) | (SRC1 << 13) | (SRC2 << 18) | (SRC3 << 23);
+  };
+};
+#pragma pack(pop)
+static_assert(sizeof(InstrKey) <= 4, "Key must be 4 bytes");
+
+template <typename... Ts>
+struct CombinedStruct;
+template <>
+struct CombinedStruct<> {};
+template <typename T, typename... Ts>
+struct CombinedStruct<T, Ts...> : T, CombinedStruct<Ts...> {};
+
+struct OpBase {};
+
+template <typename T, KeyType KEY_TYPE>
+struct Op : OpBase {
+  static const KeyType key_type = KEY_TYPE;
+};
+
+struct VoidOp : Op<VoidOp, KEY_TYPE_X> {
+ protected:
+  template <typename T, KeyType KEY_TYPE>
+  friend struct Op;
+  template <hir::Opcode OPCODE, typename... Ts>
+  friend struct I;
+  void Load(const Instr::Op& op) {}
+};
+
+struct OffsetOp : Op<OffsetOp, KEY_TYPE_O> {
+  uint64_t value;
+
+ protected:
+  template <typename T, KeyType KEY_TYPE>
+  friend struct Op;
+  template <hir::Opcode OPCODE, typename... Ts>
+  friend struct I;
+  void Load(const Instr::Op& op) { this->value = op.offset; }
+};
+
+struct SymbolOp : Op<SymbolOp, KEY_TYPE_S> {
+  Function* value;
+
+ protected:
+  template <typename T, KeyType KEY_TYPE>
+  friend struct Op;
+  template <hir::Opcode OPCODE, typename... Ts>
+  friend struct I;
+  bool Load(const Instr::Op& op) {
+    this->value = op.symbol;
+    return true;
+  }
+};
+
+struct LabelOp : Op<LabelOp, KEY_TYPE_L> {
+  hir::Label* value;
+
+ protected:
+  template <typename T, KeyType KEY_TYPE>
+  friend struct Op;
+  template <hir::Opcode OPCODE, typename... Ts>
+  friend struct I;
+  void Load(const Instr::Op& op) { this->value = op.label; }
+};
+
+template <typename T, KeyType KEY_TYPE, typename REG_TYPE, typename CONST_TYPE>
+struct ValueOp : Op<ValueOp<T, KEY_TYPE, REG_TYPE, CONST_TYPE>, KEY_TYPE> {
+  typedef REG_TYPE reg_type;
+  const Value* value;
+  bool is_constant;
+  virtual bool ConstantFitsIn32Reg() const { return true; }
+  const REG_TYPE& reg() const {
+    assert_true(!is_constant);
+    return reg_;
+  }
+  operator const REG_TYPE&() const { return reg(); }
+  bool IsEqual(const T& b) const {
+    if (is_constant && b.is_constant) {
+      return reinterpret_cast<const T*>(this)->constant() == b.constant();
+    } else if (!is_constant && !b.is_constant) {
+      return reg_.getIdx() == b.reg_.getIdx();
+    } else {
+      return false;
+    }
+  }
+  bool IsEqual(const Xbyak::Reg& b) const {
+    if (is_constant) {
+      return false;
+    } else if (!is_constant) {
+      return reg_.getIdx() == b.getIdx();
+    } else {
+      return false;
+    }
+  }
+  bool operator==(const T& b) const { return IsEqual(b); }
+  bool operator!=(const T& b) const { return !IsEqual(b); }
+  bool operator==(const Xbyak::Reg& b) const { return IsEqual(b); }
+  bool operator!=(const Xbyak::Reg& b) const { return !IsEqual(b); }
+  void Load(const Instr::Op& op) {
+    value = op.value;
+    is_constant = value->IsConstant();
+    if (!is_constant) {
+      X64Emitter::SetupReg(value, reg_);
+    }
+  }
+
+ protected:
+  REG_TYPE reg_;
+};
+
+struct I8Op : ValueOp<I8Op, KEY_TYPE_V_I8, Reg8, int8_t> {
+  typedef ValueOp<I8Op, KEY_TYPE_V_I8, Reg8, int8_t> BASE;
+  const int8_t constant() const {
+    assert_true(BASE::is_constant);
+    return BASE::value->constant.i8;
+  }
+};
+struct I16Op : ValueOp<I16Op, KEY_TYPE_V_I16, Reg16, int16_t> {
+  typedef ValueOp<I16Op, KEY_TYPE_V_I16, Reg16, int16_t> BASE;
+  const int16_t constant() const {
+    assert_true(BASE::is_constant);
+    return BASE::value->constant.i16;
+  }
+};
+struct I32Op : ValueOp<I32Op, KEY_TYPE_V_I32, Reg32, int32_t> {
+  typedef ValueOp<I32Op, KEY_TYPE_V_I32, Reg32, int32_t> BASE;
+  const int32_t constant() const {
+    assert_true(BASE::is_constant);
+    return BASE::value->constant.i32;
+  }
+};
+struct I64Op : ValueOp<I64Op, KEY_TYPE_V_I64, Reg64, int64_t> {
+  typedef ValueOp<I64Op, KEY_TYPE_V_I64, Reg64, int64_t> BASE;
+  const int64_t constant() const {
+    assert_true(BASE::is_constant);
+    return BASE::value->constant.i64;
+  }
+  bool ConstantFitsIn32Reg() const override {
+    int64_t v = BASE::value->constant.i64;
+    if ((v & ~0x7FFFFFFF) == 0) {
+      // Fits under 31 bits, so just load using normal mov.
+      return true;
+    } else if ((v & ~0x7FFFFFFF) == ~0x7FFFFFFF) {
+      // Negative number that fits in 32bits.
+      return true;
+    }
+    return false;
+  }
+};
+struct F32Op : ValueOp<F32Op, KEY_TYPE_V_F32, Xmm, float> {
+  typedef ValueOp<F32Op, KEY_TYPE_V_F32, Xmm, float> BASE;
+  const float constant() const {
+    assert_true(BASE::is_constant);
+    return BASE::value->constant.f32;
+  }
+};
+struct F64Op : ValueOp<F64Op, KEY_TYPE_V_F64, Xmm, double> {
+  typedef ValueOp<F64Op, KEY_TYPE_V_F64, Xmm, double> BASE;
+  const double constant() const {
+    assert_true(BASE::is_constant);
+    return BASE::value->constant.f64;
+  }
+};
+struct V128Op : ValueOp<V128Op, KEY_TYPE_V_V128, Xmm, vec128_t> {
+  typedef ValueOp<V128Op, KEY_TYPE_V_V128, Xmm, vec128_t> BASE;
+  const vec128_t& constant() const {
+    assert_true(BASE::is_constant);
+    return BASE::value->constant.v128;
+  }
+};
+
+template <typename DEST, typename... Tf>
+struct DestField;
+template <typename DEST>
+struct DestField<DEST> {
+  DEST dest;
+
+ protected:
+  bool LoadDest(const Instr* i) {
+    Instr::Op op;
+    op.value = i->dest;
+    dest.Load(op);
+    return true;
+  }
+};
+template <>
+struct DestField<VoidOp> {
+ protected:
+  bool LoadDest(const Instr* i) { return true; }
+};
+
+template <hir::Opcode OPCODE, typename... Ts>
+struct I;
+template <hir::Opcode OPCODE, typename DEST>
+struct I<OPCODE, DEST> : DestField<DEST> {
+  typedef DestField<DEST> BASE;
+  static const hir::Opcode opcode = OPCODE;
+  static const uint32_t key =
+      InstrKey::Construct<OPCODE, DEST::key_type>::value;
+  static const KeyType dest_type = DEST::key_type;
+  const Instr* instr;
+
+ protected:
+  template <typename SEQ, typename T>
+  friend struct Sequence;
+  bool Load(const Instr* i) {
+    if (InstrKey(i).value == key && BASE::LoadDest(i)) {
+      instr = i;
+      return true;
+    }
+    return false;
+  }
+};
+template <hir::Opcode OPCODE, typename DEST, typename SRC1>
+struct I<OPCODE, DEST, SRC1> : DestField<DEST> {
+  typedef DestField<DEST> BASE;
+  static const hir::Opcode opcode = OPCODE;
+  static const uint32_t key =
+      InstrKey::Construct<OPCODE, DEST::key_type, SRC1::key_type>::value;
+  static const KeyType dest_type = DEST::key_type;
+  static const KeyType src1_type = SRC1::key_type;
+  const Instr* instr;
+  SRC1 src1;
+
+ protected:
+  template <typename SEQ, typename T>
+  friend struct Sequence;
+  bool Load(const Instr* i) {
+    if (InstrKey(i).value == key && BASE::LoadDest(i)) {
+      instr = i;
+      src1.Load(i->src1);
+      return true;
+    }
+    return false;
+  }
+};
+template <hir::Opcode OPCODE, typename DEST, typename SRC1, typename SRC2>
+struct I<OPCODE, DEST, SRC1, SRC2> : DestField<DEST> {
+  typedef DestField<DEST> BASE;
+  static const hir::Opcode opcode = OPCODE;
+  static const uint32_t key =
+      InstrKey::Construct<OPCODE, DEST::key_type, SRC1::key_type,
+                          SRC2::key_type>::value;
+  static const KeyType dest_type = DEST::key_type;
+  static const KeyType src1_type = SRC1::key_type;
+  static const KeyType src2_type = SRC2::key_type;
+  const Instr* instr;
+  SRC1 src1;
+  SRC2 src2;
+
+ protected:
+  template <typename SEQ, typename T>
+  friend struct Sequence;
+  bool Load(const Instr* i) {
+    if (InstrKey(i).value == key && BASE::LoadDest(i)) {
+      instr = i;
+      src1.Load(i->src1);
+      src2.Load(i->src2);
+      return true;
+    }
+    return false;
+  }
+};
+template <hir::Opcode OPCODE, typename DEST, typename SRC1, typename SRC2,
+          typename SRC3>
+struct I<OPCODE, DEST, SRC1, SRC2, SRC3> : DestField<DEST> {
+  typedef DestField<DEST> BASE;
+  static const hir::Opcode opcode = OPCODE;
+  static const uint32_t key =
+      InstrKey::Construct<OPCODE, DEST::key_type, SRC1::key_type,
+                          SRC2::key_type, SRC3::key_type>::value;
+  static const KeyType dest_type = DEST::key_type;
+  static const KeyType src1_type = SRC1::key_type;
+  static const KeyType src2_type = SRC2::key_type;
+  static const KeyType src3_type = SRC3::key_type;
+  const Instr* instr;
+  SRC1 src1;
+  SRC2 src2;
+  SRC3 src3;
+
+ protected:
+  template <typename SEQ, typename T>
+  friend struct Sequence;
+  bool Load(const Instr* i) {
+    if (InstrKey(i).value == key && BASE::LoadDest(i)) {
+      instr = i;
+      src1.Load(i->src1);
+      src2.Load(i->src2);
+      src3.Load(i->src3);
+      return true;
+    }
+    return false;
+  }
+};
+
+template <typename T>
+static const T GetTempReg(X64Emitter& e);
+template <>
+const Reg8 GetTempReg<Reg8>(X64Emitter& e) {
+  return e.al;
+}
+template <>
+const Reg16 GetTempReg<Reg16>(X64Emitter& e) {
+  return e.ax;
+}
+template <>
+const Reg32 GetTempReg<Reg32>(X64Emitter& e) {
+  return e.eax;
+}
+template <>
+const Reg64 GetTempReg<Reg64>(X64Emitter& e) {
+  return e.rax;
+}
+
+template <typename SEQ, typename T>
+struct Sequence {
+  typedef T EmitArgType;
+
+  static constexpr uint32_t head_key() { return T::key; }
+
+  static bool Select(X64Emitter& e, const Instr* i) {
+    T args;
+    if (!args.Load(i)) {
+      return false;
+    }
+    SEQ::Emit(e, args);
+    return true;
+  }
+
+  template <typename REG_FN>
+  static void EmitUnaryOp(X64Emitter& e, const EmitArgType& i,
+                          const REG_FN& reg_fn) {
+    if (i.src1.is_constant) {
+      e.mov(i.dest, i.src1.constant());
+      reg_fn(e, i.dest);
+    } else {
+      if (i.dest != i.src1) {
+        e.mov(i.dest, i.src1);
+      }
+      reg_fn(e, i.dest);
+    }
+  }
+
+  template <typename REG_REG_FN, typename REG_CONST_FN>
+  static void EmitCommutativeBinaryOp(X64Emitter& e, const EmitArgType& i,
+                                      const REG_REG_FN& reg_reg_fn,
+                                      const REG_CONST_FN& reg_const_fn) {
+    if (i.src1.is_constant) {
+      if (i.src2.is_constant) {
+        // Both constants.
+        if (i.src1.ConstantFitsIn32Reg()) {
+          e.mov(i.dest, i.src2.constant());
+          reg_const_fn(e, i.dest, static_cast<int32_t>(i.src1.constant()));
+        } else if (i.src2.ConstantFitsIn32Reg()) {
+          e.mov(i.dest, i.src1.constant());
+          reg_const_fn(e, i.dest, static_cast<int32_t>(i.src2.constant()));
+        } else {
+          e.mov(i.dest, i.src1.constant());
+          auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
+          e.mov(temp, i.src2.constant());
+          reg_reg_fn(e, i.dest, temp);
+        }
+      } else {
+        // src1 constant.
+        if (i.dest == i.src2) {
+          if (i.src1.ConstantFitsIn32Reg()) {
+            reg_const_fn(e, i.dest, static_cast<int32_t>(i.src1.constant()));
+          } else {
+            auto temp = GetTempReg<typename decltype(i.src1)::reg_type>(e);
+            e.mov(temp, i.src1.constant());
+            reg_reg_fn(e, i.dest, temp);
+          }
+        } else {
+          e.mov(i.dest, i.src1.constant());
+          reg_reg_fn(e, i.dest, i.src2);
+        }
+      }
+    } else if (i.src2.is_constant) {
+      if (i.dest == i.src1) {
+        if (i.src2.ConstantFitsIn32Reg()) {
+          reg_const_fn(e, i.dest, static_cast<int32_t>(i.src2.constant()));
+        } else {
+          auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
+          e.mov(temp, i.src2.constant());
+          reg_reg_fn(e, i.dest, temp);
+        }
+      } else {
+        e.mov(i.dest, i.src2.constant());
+        reg_reg_fn(e, i.dest, i.src1);
+      }
+    } else {
+      if (i.dest == i.src1) {
+        reg_reg_fn(e, i.dest, i.src2);
+      } else if (i.dest == i.src2) {
+        reg_reg_fn(e, i.dest, i.src1);
+      } else {
+        e.mov(i.dest, i.src1);
+        reg_reg_fn(e, i.dest, i.src2);
+      }
+    }
+  }
+  template <typename REG_REG_FN, typename REG_CONST_FN>
+  static void EmitAssociativeBinaryOp(X64Emitter& e, const EmitArgType& i,
+                                      const REG_REG_FN& reg_reg_fn,
+                                      const REG_CONST_FN& reg_const_fn) {
+    if (i.src1.is_constant) {
+      assert_true(!i.src2.is_constant);
+      if (i.dest == i.src2) {
+        auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
+        e.mov(temp, i.src2);
+        e.mov(i.dest, i.src1.constant());
+        reg_reg_fn(e, i.dest, temp);
+      } else {
+        e.mov(i.dest, i.src1.constant());
+        reg_reg_fn(e, i.dest, i.src2);
+      }
+    } else if (i.src2.is_constant) {
+      if (i.dest == i.src1) {
+        if (i.src2.ConstantFitsIn32Reg()) {
+          reg_const_fn(e, i.dest, static_cast<int32_t>(i.src2.constant()));
+        } else {
+          auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
+          e.mov(temp, i.src2.constant());
+          reg_reg_fn(e, i.dest, temp);
+        }
+      } else {
+        e.mov(i.dest, i.src1);
+        if (i.src2.ConstantFitsIn32Reg()) {
+          reg_const_fn(e, i.dest, static_cast<int32_t>(i.src2.constant()));
+        } else {
+          auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
+          e.mov(temp, i.src2.constant());
+          reg_reg_fn(e, i.dest, temp);
+        }
+      }
+    } else {
+      if (i.dest == i.src1) {
+        reg_reg_fn(e, i.dest, i.src2);
+      } else if (i.dest == i.src2) {
+        auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
+        e.mov(temp, i.src2);
+        e.mov(i.dest, i.src1);
+        reg_reg_fn(e, i.dest, temp);
+      } else {
+        e.mov(i.dest, i.src1);
+        reg_reg_fn(e, i.dest, i.src2);
+      }
+    }
+  }
+
+  template <typename FN>
+  static void EmitCommutativeBinaryXmmOp(X64Emitter& e, const EmitArgType& i,
+                                         const FN& fn) {
+    if (i.src1.is_constant) {
+      assert_true(!i.src2.is_constant);
+      e.LoadConstantXmm(e.xmm0, i.src1.constant());
+      fn(e, i.dest, e.xmm0, i.src2);
+    } else if (i.src2.is_constant) {
+      assert_true(!i.src1.is_constant);
+      e.LoadConstantXmm(e.xmm0, i.src2.constant());
+      fn(e, i.dest, i.src1, e.xmm0);
+    } else {
+      fn(e, i.dest, i.src1, i.src2);
+    }
+  }
+
+  template <typename FN>
+  static void EmitAssociativeBinaryXmmOp(X64Emitter& e, const EmitArgType& i,
+                                         const FN& fn) {
+    if (i.src1.is_constant) {
+      assert_true(!i.src2.is_constant);
+      e.LoadConstantXmm(e.xmm0, i.src1.constant());
+      fn(e, i.dest, e.xmm0, i.src2);
+    } else if (i.src2.is_constant) {
+      assert_true(!i.src1.is_constant);
+      e.LoadConstantXmm(e.xmm0, i.src2.constant());
+      fn(e, i.dest, i.src1, e.xmm0);
+    } else {
+      fn(e, i.dest, i.src1, i.src2);
+    }
+  }
+
+  template <typename REG_REG_FN, typename REG_CONST_FN>
+  static void EmitCommutativeCompareOp(X64Emitter& e, const EmitArgType& i,
+                                       const REG_REG_FN& reg_reg_fn,
+                                       const REG_CONST_FN& reg_const_fn) {
+    if (i.src1.is_constant) {
+      assert_true(!i.src2.is_constant);
+      if (i.src1.ConstantFitsIn32Reg()) {
+        reg_const_fn(e, i.src2, static_cast<int32_t>(i.src1.constant()));
+      } else {
+        auto temp = GetTempReg<typename decltype(i.src1)::reg_type>(e);
+        e.mov(temp, i.src1.constant());
+        reg_reg_fn(e, i.src2, temp);
+      }
+    } else if (i.src2.is_constant) {
+      assert_true(!i.src1.is_constant);
+      if (i.src2.ConstantFitsIn32Reg()) {
+        reg_const_fn(e, i.src1, static_cast<int32_t>(i.src2.constant()));
+      } else {
+        auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
+        e.mov(temp, i.src2.constant());
+        reg_reg_fn(e, i.src1, temp);
+      }
+    } else {
+      reg_reg_fn(e, i.src1, i.src2);
+    }
+  }
+  template <typename REG_REG_FN, typename REG_CONST_FN>
+  static void EmitAssociativeCompareOp(X64Emitter& e, const EmitArgType& i,
+                                       const REG_REG_FN& reg_reg_fn,
+                                       const REG_CONST_FN& reg_const_fn) {
+    if (i.src1.is_constant) {
+      assert_true(!i.src2.is_constant);
+      if (i.src1.ConstantFitsIn32Reg()) {
+        reg_const_fn(e, i.dest, i.src2, static_cast<int32_t>(i.src1.constant()),
+                     true);
+      } else {
+        auto temp = GetTempReg<typename decltype(i.src1)::reg_type>(e);
+        e.mov(temp, i.src1.constant());
+        reg_reg_fn(e, i.dest, i.src2, temp, true);
+      }
+    } else if (i.src2.is_constant) {
+      assert_true(!i.src1.is_constant);
+      if (i.src2.ConstantFitsIn32Reg()) {
+        reg_const_fn(e, i.dest, i.src1, static_cast<int32_t>(i.src2.constant()),
+                     false);
+      } else {
+        auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
+        e.mov(temp, i.src2.constant());
+        reg_reg_fn(e, i.dest, i.src1, temp, false);
+      }
+    } else {
+      reg_reg_fn(e, i.dest, i.src1, i.src2, false);
+    }
+  }
+};
+
+}  // namespace x64
+}  // namespace backend
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_CPU_BACKEND_X64_X64_OP_H_
diff --git a/src/xenia/cpu/backend/x64/x64_seq_control.cc b/src/xenia/cpu/backend/x64/x64_seq_control.cc
new file mode 100644
index 000000000..80eeeebc7
--- /dev/null
+++ b/src/xenia/cpu/backend/x64/x64_seq_control.cc
@@ -0,0 +1,553 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2018 Xenia Developers. All rights reserved.                      *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "xenia/cpu/backend/x64/x64_sequences.h"
+
+#include <algorithm>
+#include <cstring>
+
+#include "xenia/cpu/backend/x64/x64_op.h"
+
+namespace xe {
+namespace cpu {
+namespace backend {
+namespace x64 {
+
+volatile int anchor_control = 0;
+
+// ============================================================================
+// OPCODE_DEBUG_BREAK
+// ============================================================================
+struct DEBUG_BREAK : Sequence<DEBUG_BREAK, I<OPCODE_DEBUG_BREAK, VoidOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) { e.DebugBreak(); }
+};
+EMITTER_OPCODE_TABLE(OPCODE_DEBUG_BREAK, DEBUG_BREAK);
+
+// ============================================================================
+// OPCODE_DEBUG_BREAK_TRUE
+// ============================================================================
+struct DEBUG_BREAK_TRUE_I8
+    : Sequence<DEBUG_BREAK_TRUE_I8, I<OPCODE_DEBUG_BREAK_TRUE, VoidOp, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.DebugBreak();
+    e.L(skip);
+  }
+};
+struct DEBUG_BREAK_TRUE_I16
+    : Sequence<DEBUG_BREAK_TRUE_I16,
+               I<OPCODE_DEBUG_BREAK_TRUE, VoidOp, I16Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.DebugBreak();
+    e.L(skip);
+  }
+};
+struct DEBUG_BREAK_TRUE_I32
+    : Sequence<DEBUG_BREAK_TRUE_I32,
+               I<OPCODE_DEBUG_BREAK_TRUE, VoidOp, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.DebugBreak();
+    e.L(skip);
+  }
+};
+struct DEBUG_BREAK_TRUE_I64
+    : Sequence<DEBUG_BREAK_TRUE_I64,
+               I<OPCODE_DEBUG_BREAK_TRUE, VoidOp, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.DebugBreak();
+    e.L(skip);
+  }
+};
+struct DEBUG_BREAK_TRUE_F32
+    : Sequence<DEBUG_BREAK_TRUE_F32,
+               I<OPCODE_DEBUG_BREAK_TRUE, VoidOp, F32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vptest(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.DebugBreak();
+    e.L(skip);
+  }
+};
+struct DEBUG_BREAK_TRUE_F64
+    : Sequence<DEBUG_BREAK_TRUE_F64,
+               I<OPCODE_DEBUG_BREAK_TRUE, VoidOp, F64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vptest(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.DebugBreak();
+    e.L(skip);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_DEBUG_BREAK_TRUE, DEBUG_BREAK_TRUE_I8,
+                     DEBUG_BREAK_TRUE_I16, DEBUG_BREAK_TRUE_I32,
+                     DEBUG_BREAK_TRUE_I64, DEBUG_BREAK_TRUE_F32,
+                     DEBUG_BREAK_TRUE_F64);
+
+// ============================================================================
+// OPCODE_TRAP
+// ============================================================================
+struct TRAP : Sequence<TRAP, I<OPCODE_TRAP, VoidOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.Trap(i.instr->flags);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_TRAP, TRAP);
+
+// ============================================================================
+// OPCODE_TRAP_TRUE
+// ============================================================================
+struct TRAP_TRUE_I8
+    : Sequence<TRAP_TRUE_I8, I<OPCODE_TRAP_TRUE, VoidOp, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.Trap(i.instr->flags);
+    e.L(skip);
+  }
+};
+struct TRAP_TRUE_I16
+    : Sequence<TRAP_TRUE_I16, I<OPCODE_TRAP_TRUE, VoidOp, I16Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.Trap(i.instr->flags);
+    e.L(skip);
+  }
+};
+struct TRAP_TRUE_I32
+    : Sequence<TRAP_TRUE_I32, I<OPCODE_TRAP_TRUE, VoidOp, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.Trap(i.instr->flags);
+    e.L(skip);
+  }
+};
+struct TRAP_TRUE_I64
+    : Sequence<TRAP_TRUE_I64, I<OPCODE_TRAP_TRUE, VoidOp, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.Trap(i.instr->flags);
+    e.L(skip);
+  }
+};
+struct TRAP_TRUE_F32
+    : Sequence<TRAP_TRUE_F32, I<OPCODE_TRAP_TRUE, VoidOp, F32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vptest(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.Trap(i.instr->flags);
+    e.L(skip);
+  }
+};
+struct TRAP_TRUE_F64
+    : Sequence<TRAP_TRUE_F64, I<OPCODE_TRAP_TRUE, VoidOp, F64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vptest(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.Trap(i.instr->flags);
+    e.L(skip);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_TRAP_TRUE, TRAP_TRUE_I8, TRAP_TRUE_I16,
+                     TRAP_TRUE_I32, TRAP_TRUE_I64, TRAP_TRUE_F32,
+                     TRAP_TRUE_F64);
+
+// ============================================================================
+// OPCODE_CALL
+// ============================================================================
+struct CALL : Sequence<CALL, I<OPCODE_CALL, VoidOp, SymbolOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src1.value->is_guest());
+    e.Call(i.instr, static_cast<GuestFunction*>(i.src1.value));
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_CALL, CALL);
+
+// ============================================================================
+// OPCODE_CALL_TRUE
+// ============================================================================
+struct CALL_TRUE_I8
+    : Sequence<CALL_TRUE_I8, I<OPCODE_CALL_TRUE, VoidOp, I8Op, SymbolOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.value->is_guest());
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.Call(i.instr, static_cast<GuestFunction*>(i.src2.value));
+    e.L(skip);
+  }
+};
+struct CALL_TRUE_I16
+    : Sequence<CALL_TRUE_I16, I<OPCODE_CALL_TRUE, VoidOp, I16Op, SymbolOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.value->is_guest());
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.Call(i.instr, static_cast<GuestFunction*>(i.src2.value));
+    e.L(skip);
+  }
+};
+struct CALL_TRUE_I32
+    : Sequence<CALL_TRUE_I32, I<OPCODE_CALL_TRUE, VoidOp, I32Op, SymbolOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.value->is_guest());
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.Call(i.instr, static_cast<GuestFunction*>(i.src2.value));
+    e.L(skip);
+  }
+};
+struct CALL_TRUE_I64
+    : Sequence<CALL_TRUE_I64, I<OPCODE_CALL_TRUE, VoidOp, I64Op, SymbolOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.value->is_guest());
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.Call(i.instr, static_cast<GuestFunction*>(i.src2.value));
+    e.L(skip);
+  }
+};
+struct CALL_TRUE_F32
+    : Sequence<CALL_TRUE_F32, I<OPCODE_CALL_TRUE, VoidOp, F32Op, SymbolOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.value->is_guest());
+    e.vptest(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.Call(i.instr, static_cast<GuestFunction*>(i.src2.value));
+    e.L(skip);
+  }
+};
+struct CALL_TRUE_F64
+    : Sequence<CALL_TRUE_F64, I<OPCODE_CALL_TRUE, VoidOp, F64Op, SymbolOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.value->is_guest());
+    e.vptest(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip);
+    e.Call(i.instr, static_cast<GuestFunction*>(i.src2.value));
+    e.L(skip);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_CALL_TRUE, CALL_TRUE_I8, CALL_TRUE_I16,
+                     CALL_TRUE_I32, CALL_TRUE_I64, CALL_TRUE_F32,
+                     CALL_TRUE_F64);
+
+// ============================================================================
+// OPCODE_CALL_INDIRECT
+// ============================================================================
+struct CALL_INDIRECT
+    : Sequence<CALL_INDIRECT, I<OPCODE_CALL_INDIRECT, VoidOp, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.CallIndirect(i.instr, i.src1);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_CALL_INDIRECT, CALL_INDIRECT);
+
+// ============================================================================
+// OPCODE_CALL_INDIRECT_TRUE
+// ============================================================================
+struct CALL_INDIRECT_TRUE_I8
+    : Sequence<CALL_INDIRECT_TRUE_I8,
+               I<OPCODE_CALL_INDIRECT_TRUE, VoidOp, I8Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip, CodeGenerator::T_NEAR);
+    e.CallIndirect(i.instr, i.src2);
+    e.L(skip);
+  }
+};
+struct CALL_INDIRECT_TRUE_I16
+    : Sequence<CALL_INDIRECT_TRUE_I16,
+               I<OPCODE_CALL_INDIRECT_TRUE, VoidOp, I16Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip, CodeGenerator::T_NEAR);
+    e.CallIndirect(i.instr, i.src2);
+    e.L(skip);
+  }
+};
+struct CALL_INDIRECT_TRUE_I32
+    : Sequence<CALL_INDIRECT_TRUE_I32,
+               I<OPCODE_CALL_INDIRECT_TRUE, VoidOp, I32Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip, CodeGenerator::T_NEAR);
+    e.CallIndirect(i.instr, i.src2);
+    e.L(skip);
+  }
+};
+struct CALL_INDIRECT_TRUE_I64
+    : Sequence<CALL_INDIRECT_TRUE_I64,
+               I<OPCODE_CALL_INDIRECT_TRUE, VoidOp, I64Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip, CodeGenerator::T_NEAR);
+    e.CallIndirect(i.instr, i.src2);
+    e.L(skip);
+  }
+};
+struct CALL_INDIRECT_TRUE_F32
+    : Sequence<CALL_INDIRECT_TRUE_F32,
+               I<OPCODE_CALL_INDIRECT_TRUE, VoidOp, F32Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vptest(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip, CodeGenerator::T_NEAR);
+    e.CallIndirect(i.instr, i.src2);
+    e.L(skip);
+  }
+};
+struct CALL_INDIRECT_TRUE_F64
+    : Sequence<CALL_INDIRECT_TRUE_F64,
+               I<OPCODE_CALL_INDIRECT_TRUE, VoidOp, F64Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vptest(i.src1, i.src1);
+    Xbyak::Label skip;
+    e.jz(skip, CodeGenerator::T_NEAR);
+    e.CallIndirect(i.instr, i.src2);
+    e.L(skip);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_CALL_INDIRECT_TRUE, CALL_INDIRECT_TRUE_I8,
+                     CALL_INDIRECT_TRUE_I16, CALL_INDIRECT_TRUE_I32,
+                     CALL_INDIRECT_TRUE_I64, CALL_INDIRECT_TRUE_F32,
+                     CALL_INDIRECT_TRUE_F64);
+
+// ============================================================================
+// OPCODE_CALL_EXTERN
+// ============================================================================
+struct CALL_EXTERN
+    : Sequence<CALL_EXTERN, I<OPCODE_CALL_EXTERN, VoidOp, SymbolOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.CallExtern(i.instr, i.src1.value);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_CALL_EXTERN, CALL_EXTERN);
+
+// ============================================================================
+// OPCODE_RETURN
+// ============================================================================
+struct RETURN : Sequence<RETURN, I<OPCODE_RETURN, VoidOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    // If this is the last instruction in the last block, just let us
+    // fall through.
+    if (i.instr->next || i.instr->block->next) {
+      e.jmp(e.epilog_label(), CodeGenerator::T_NEAR);
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_RETURN, RETURN);
+
+// ============================================================================
+// OPCODE_RETURN_TRUE
+// ============================================================================
+struct RETURN_TRUE_I8
+    : Sequence<RETURN_TRUE_I8, I<OPCODE_RETURN_TRUE, VoidOp, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    e.jnz(e.epilog_label(), CodeGenerator::T_NEAR);
+  }
+};
+struct RETURN_TRUE_I16
+    : Sequence<RETURN_TRUE_I16, I<OPCODE_RETURN_TRUE, VoidOp, I16Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    e.jnz(e.epilog_label(), CodeGenerator::T_NEAR);
+  }
+};
+struct RETURN_TRUE_I32
+    : Sequence<RETURN_TRUE_I32, I<OPCODE_RETURN_TRUE, VoidOp, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    e.jnz(e.epilog_label(), CodeGenerator::T_NEAR);
+  }
+};
+struct RETURN_TRUE_I64
+    : Sequence<RETURN_TRUE_I64, I<OPCODE_RETURN_TRUE, VoidOp, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    e.jnz(e.epilog_label(), CodeGenerator::T_NEAR);
+  }
+};
+struct RETURN_TRUE_F32
+    : Sequence<RETURN_TRUE_F32, I<OPCODE_RETURN_TRUE, VoidOp, F32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vptest(i.src1, i.src1);
+    e.jnz(e.epilog_label(), CodeGenerator::T_NEAR);
+  }
+};
+struct RETURN_TRUE_F64
+    : Sequence<RETURN_TRUE_F64, I<OPCODE_RETURN_TRUE, VoidOp, F64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vptest(i.src1, i.src1);
+    e.jnz(e.epilog_label(), CodeGenerator::T_NEAR);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_RETURN_TRUE, RETURN_TRUE_I8, RETURN_TRUE_I16,
+                     RETURN_TRUE_I32, RETURN_TRUE_I64, RETURN_TRUE_F32,
+                     RETURN_TRUE_F64);
+
+// ============================================================================
+// OPCODE_SET_RETURN_ADDRESS
+// ============================================================================
+struct SET_RETURN_ADDRESS
+    : Sequence<SET_RETURN_ADDRESS,
+               I<OPCODE_SET_RETURN_ADDRESS, VoidOp, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.SetReturnAddress(i.src1.constant());
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_SET_RETURN_ADDRESS, SET_RETURN_ADDRESS);
+
+// ============================================================================
+// OPCODE_BRANCH
+// ============================================================================
+struct BRANCH : Sequence<BRANCH, I<OPCODE_BRANCH, VoidOp, LabelOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.jmp(i.src1.value->name, e.T_NEAR);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_BRANCH, BRANCH);
+
+// ============================================================================
+// OPCODE_BRANCH_TRUE
+// ============================================================================
+struct BRANCH_TRUE_I8
+    : Sequence<BRANCH_TRUE_I8, I<OPCODE_BRANCH_TRUE, VoidOp, I8Op, LabelOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    e.jnz(i.src2.value->name, e.T_NEAR);
+  }
+};
+struct BRANCH_TRUE_I16
+    : Sequence<BRANCH_TRUE_I16, I<OPCODE_BRANCH_TRUE, VoidOp, I16Op, LabelOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    e.jnz(i.src2.value->name, e.T_NEAR);
+  }
+};
+struct BRANCH_TRUE_I32
+    : Sequence<BRANCH_TRUE_I32, I<OPCODE_BRANCH_TRUE, VoidOp, I32Op, LabelOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    e.jnz(i.src2.value->name, e.T_NEAR);
+  }
+};
+struct BRANCH_TRUE_I64
+    : Sequence<BRANCH_TRUE_I64, I<OPCODE_BRANCH_TRUE, VoidOp, I64Op, LabelOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    e.jnz(i.src2.value->name, e.T_NEAR);
+  }
+};
+struct BRANCH_TRUE_F32
+    : Sequence<BRANCH_TRUE_F32, I<OPCODE_BRANCH_TRUE, VoidOp, F32Op, LabelOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vptest(i.src1, i.src1);
+    e.jnz(i.src2.value->name, e.T_NEAR);
+  }
+};
+struct BRANCH_TRUE_F64
+    : Sequence<BRANCH_TRUE_F64, I<OPCODE_BRANCH_TRUE, VoidOp, F64Op, LabelOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vptest(i.src1, i.src1);
+    e.jnz(i.src2.value->name, e.T_NEAR);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_BRANCH_TRUE, BRANCH_TRUE_I8, BRANCH_TRUE_I16,
+                     BRANCH_TRUE_I32, BRANCH_TRUE_I64, BRANCH_TRUE_F32,
+                     BRANCH_TRUE_F64);
+
+// ============================================================================
+// OPCODE_BRANCH_FALSE
+// ============================================================================
+struct BRANCH_FALSE_I8
+    : Sequence<BRANCH_FALSE_I8, I<OPCODE_BRANCH_FALSE, VoidOp, I8Op, LabelOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    e.jz(i.src2.value->name, e.T_NEAR);
+  }
+};
+struct BRANCH_FALSE_I16
+    : Sequence<BRANCH_FALSE_I16,
+               I<OPCODE_BRANCH_FALSE, VoidOp, I16Op, LabelOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    e.jz(i.src2.value->name, e.T_NEAR);
+  }
+};
+struct BRANCH_FALSE_I32
+    : Sequence<BRANCH_FALSE_I32,
+               I<OPCODE_BRANCH_FALSE, VoidOp, I32Op, LabelOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    e.jz(i.src2.value->name, e.T_NEAR);
+  }
+};
+struct BRANCH_FALSE_I64
+    : Sequence<BRANCH_FALSE_I64,
+               I<OPCODE_BRANCH_FALSE, VoidOp, I64Op, LabelOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.test(i.src1, i.src1);
+    e.jz(i.src2.value->name, e.T_NEAR);
+  }
+};
+struct BRANCH_FALSE_F32
+    : Sequence<BRANCH_FALSE_F32,
+               I<OPCODE_BRANCH_FALSE, VoidOp, F32Op, LabelOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vptest(i.src1, i.src1);
+    e.jz(i.src2.value->name, e.T_NEAR);
+  }
+};
+struct BRANCH_FALSE_F64
+    : Sequence<BRANCH_FALSE_F64,
+               I<OPCODE_BRANCH_FALSE, VoidOp, F64Op, LabelOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vptest(i.src1, i.src1);
+    e.jz(i.src2.value->name, e.T_NEAR);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_BRANCH_FALSE, BRANCH_FALSE_I8, BRANCH_FALSE_I16,
+                     BRANCH_FALSE_I32, BRANCH_FALSE_I64, BRANCH_FALSE_F32,
+                     BRANCH_FALSE_F64);
+
+}  // namespace x64
+}  // namespace backend
+}  // namespace cpu
+}  // namespace xe
\ No newline at end of file
diff --git a/src/xenia/cpu/backend/x64/x64_seq_memory.cc b/src/xenia/cpu/backend/x64/x64_seq_memory.cc
new file mode 100644
index 000000000..7526d1fc8
--- /dev/null
+++ b/src/xenia/cpu/backend/x64/x64_seq_memory.cc
@@ -0,0 +1,1053 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2018 Xenia Developers. All rights reserved.                      *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "xenia/cpu/backend/x64/x64_sequences.h"
+
+#include <algorithm>
+#include <cstring>
+
+#include "xenia/cpu/backend/x64/x64_op.h"
+#include "xenia/cpu/backend/x64/x64_tracers.h"
+
+namespace xe {
+namespace cpu {
+namespace backend {
+namespace x64 {
+
+volatile int anchor_memory = 0;
+
+// Note: all types are always aligned in the context.
+RegExp ComputeContextAddress(X64Emitter& e, const OffsetOp& offset) {
+  return e.GetContextReg() + offset.value;
+}
+
+template <typename T>
+RegExp ComputeMemoryAddressOffset(X64Emitter& e, const T& guest,
+                                  const T& offset) {
+  assert_true(offset.is_constant);
+  int32_t offset_const = static_cast<int32_t>(offset.constant());
+
+  if (guest.is_constant) {
+    uint32_t address = static_cast<uint32_t>(guest.constant());
+    address += offset_const;
+    if (address < 0x80000000) {
+      return e.GetMembaseReg() + address;
+    } else {
+      e.mov(e.eax, address);
+      return e.GetMembaseReg() + e.rax;
+    }
+  } else {
+    // Clear the top 32 bits, as they are likely garbage.
+    // TODO(benvanik): find a way to avoid doing this.
+    e.mov(e.eax, guest.reg().cvt32());
+    return e.GetMembaseReg() + e.rax + offset_const;
+  }
+}
+
+// Note: most *should* be aligned, but needs to be checked!
+template <typename T>
+RegExp ComputeMemoryAddress(X64Emitter& e, const T& guest) {
+  if (guest.is_constant) {
+    // TODO(benvanik): figure out how to do this without a temp.
+    // Since the constant is often 0x8... if we tried to use that as a
+    // displacement it would be sign extended and mess things up.
+    uint32_t address = static_cast<uint32_t>(guest.constant());
+    if (address < 0x80000000) {
+      return e.GetMembaseReg() + address;
+    } else {
+      e.mov(e.eax, address);
+      return e.GetMembaseReg() + e.rax;
+    }
+  } else {
+    // Clear the top 32 bits, as they are likely garbage.
+    // TODO(benvanik): find a way to avoid doing this.
+    e.mov(e.eax, guest.reg().cvt32());
+    return e.GetMembaseReg() + e.rax;
+  }
+}
+
+// ============================================================================
+// OPCODE_ATOMIC_EXCHANGE
+// ============================================================================
+// Note that the address we use here is a real, host address!
+// This is weird, and should be fixed.
+template <typename SEQ, typename REG, typename ARGS>
+void EmitAtomicExchangeXX(X64Emitter& e, const ARGS& i) {
+  if (i.dest == i.src1) {
+    e.mov(e.rax, i.src1);
+    if (i.dest != i.src2) {
+      if (i.src2.is_constant) {
+        e.mov(i.dest, i.src2.constant());
+      } else {
+        e.mov(i.dest, i.src2);
+      }
+    }
+    e.lock();
+    e.xchg(e.dword[e.rax], i.dest);
+  } else {
+    if (i.dest != i.src2) {
+      if (i.src2.is_constant) {
+        e.mov(i.dest, i.src2.constant());
+      } else {
+        e.mov(i.dest, i.src2);
+      }
+    }
+    e.lock();
+    e.xchg(e.dword[i.src1.reg()], i.dest);
+  }
+}
+struct ATOMIC_EXCHANGE_I8
+    : Sequence<ATOMIC_EXCHANGE_I8,
+               I<OPCODE_ATOMIC_EXCHANGE, I8Op, I64Op, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    EmitAtomicExchangeXX<ATOMIC_EXCHANGE_I8, Reg8>(e, i);
+  }
+};
+struct ATOMIC_EXCHANGE_I16
+    : Sequence<ATOMIC_EXCHANGE_I16,
+               I<OPCODE_ATOMIC_EXCHANGE, I16Op, I64Op, I16Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    EmitAtomicExchangeXX<ATOMIC_EXCHANGE_I16, Reg16>(e, i);
+  }
+};
+struct ATOMIC_EXCHANGE_I32
+    : Sequence<ATOMIC_EXCHANGE_I32,
+               I<OPCODE_ATOMIC_EXCHANGE, I32Op, I64Op, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    EmitAtomicExchangeXX<ATOMIC_EXCHANGE_I32, Reg32>(e, i);
+  }
+};
+struct ATOMIC_EXCHANGE_I64
+    : Sequence<ATOMIC_EXCHANGE_I64,
+               I<OPCODE_ATOMIC_EXCHANGE, I64Op, I64Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    EmitAtomicExchangeXX<ATOMIC_EXCHANGE_I64, Reg64>(e, i);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_ATOMIC_EXCHANGE, ATOMIC_EXCHANGE_I8,
+                     ATOMIC_EXCHANGE_I16, ATOMIC_EXCHANGE_I32,
+                     ATOMIC_EXCHANGE_I64);
+
+// ============================================================================
+// OPCODE_ATOMIC_COMPARE_EXCHANGE
+// ============================================================================
+struct ATOMIC_COMPARE_EXCHANGE_I32
+    : Sequence<ATOMIC_COMPARE_EXCHANGE_I32,
+               I<OPCODE_ATOMIC_COMPARE_EXCHANGE, I8Op, I64Op, I32Op, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.mov(e.eax, i.src2);
+    e.mov(e.ecx, i.src1.reg().cvt32());
+    e.lock();
+    e.cmpxchg(e.dword[e.GetMembaseReg() + e.rcx], i.src3);
+    e.sete(i.dest);
+  }
+};
+struct ATOMIC_COMPARE_EXCHANGE_I64
+    : Sequence<ATOMIC_COMPARE_EXCHANGE_I64,
+               I<OPCODE_ATOMIC_COMPARE_EXCHANGE, I8Op, I64Op, I64Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.mov(e.rax, i.src2);
+    e.mov(e.ecx, i.src1.reg().cvt32());
+    e.lock();
+    e.cmpxchg(e.qword[e.GetMembaseReg() + e.rcx], i.src3);
+    e.sete(i.dest);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_ATOMIC_COMPARE_EXCHANGE,
+                     ATOMIC_COMPARE_EXCHANGE_I32, ATOMIC_COMPARE_EXCHANGE_I64);
+
+// ============================================================================
+// OPCODE_LOAD_LOCAL
+// ============================================================================
+// Note: all types are always aligned on the stack.
+struct LOAD_LOCAL_I8
+    : Sequence<LOAD_LOCAL_I8, I<OPCODE_LOAD_LOCAL, I8Op, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.mov(i.dest, e.byte[e.rsp + i.src1.constant()]);
+    // e.TraceLoadI8(DATA_LOCAL, i.src1.constant, i.dest);
+  }
+};
+struct LOAD_LOCAL_I16
+    : Sequence<LOAD_LOCAL_I16, I<OPCODE_LOAD_LOCAL, I16Op, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.mov(i.dest, e.word[e.rsp + i.src1.constant()]);
+    // e.TraceLoadI16(DATA_LOCAL, i.src1.constant, i.dest);
+  }
+};
+struct LOAD_LOCAL_I32
+    : Sequence<LOAD_LOCAL_I32, I<OPCODE_LOAD_LOCAL, I32Op, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.mov(i.dest, e.dword[e.rsp + i.src1.constant()]);
+    // e.TraceLoadI32(DATA_LOCAL, i.src1.constant, i.dest);
+  }
+};
+struct LOAD_LOCAL_I64
+    : Sequence<LOAD_LOCAL_I64, I<OPCODE_LOAD_LOCAL, I64Op, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.mov(i.dest, e.qword[e.rsp + i.src1.constant()]);
+    // e.TraceLoadI64(DATA_LOCAL, i.src1.constant, i.dest);
+  }
+};
+struct LOAD_LOCAL_F32
+    : Sequence<LOAD_LOCAL_F32, I<OPCODE_LOAD_LOCAL, F32Op, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vmovss(i.dest, e.dword[e.rsp + i.src1.constant()]);
+    // e.TraceLoadF32(DATA_LOCAL, i.src1.constant, i.dest);
+  }
+};
+struct LOAD_LOCAL_F64
+    : Sequence<LOAD_LOCAL_F64, I<OPCODE_LOAD_LOCAL, F64Op, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vmovsd(i.dest, e.qword[e.rsp + i.src1.constant()]);
+    // e.TraceLoadF64(DATA_LOCAL, i.src1.constant, i.dest);
+  }
+};
+struct LOAD_LOCAL_V128
+    : Sequence<LOAD_LOCAL_V128, I<OPCODE_LOAD_LOCAL, V128Op, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    e.vmovaps(i.dest, e.ptr[e.rsp + i.src1.constant()]);
+    // e.TraceLoadV128(DATA_LOCAL, i.src1.constant, i.dest);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_LOAD_LOCAL, LOAD_LOCAL_I8, LOAD_LOCAL_I16,
+                     LOAD_LOCAL_I32, LOAD_LOCAL_I64, LOAD_LOCAL_F32,
+                     LOAD_LOCAL_F64, LOAD_LOCAL_V128);
+
+// ============================================================================
+// OPCODE_STORE_LOCAL
+// ============================================================================
+// Note: all types are always aligned on the stack.
+struct STORE_LOCAL_I8
+    : Sequence<STORE_LOCAL_I8, I<OPCODE_STORE_LOCAL, VoidOp, I32Op, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    // e.TraceStoreI8(DATA_LOCAL, i.src1.constant, i.src2);
+    e.mov(e.byte[e.rsp + i.src1.constant()], i.src2);
+  }
+};
+struct STORE_LOCAL_I16
+    : Sequence<STORE_LOCAL_I16, I<OPCODE_STORE_LOCAL, VoidOp, I32Op, I16Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    // e.TraceStoreI16(DATA_LOCAL, i.src1.constant, i.src2);
+    e.mov(e.word[e.rsp + i.src1.constant()], i.src2);
+  }
+};
+struct STORE_LOCAL_I32
+    : Sequence<STORE_LOCAL_I32, I<OPCODE_STORE_LOCAL, VoidOp, I32Op, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    // e.TraceStoreI32(DATA_LOCAL, i.src1.constant, i.src2);
+    e.mov(e.dword[e.rsp + i.src1.constant()], i.src2);
+  }
+};
+struct STORE_LOCAL_I64
+    : Sequence<STORE_LOCAL_I64, I<OPCODE_STORE_LOCAL, VoidOp, I32Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    // e.TraceStoreI64(DATA_LOCAL, i.src1.constant, i.src2);
+    e.mov(e.qword[e.rsp + i.src1.constant()], i.src2);
+  }
+};
+struct STORE_LOCAL_F32
+    : Sequence<STORE_LOCAL_F32, I<OPCODE_STORE_LOCAL, VoidOp, I32Op, F32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    // e.TraceStoreF32(DATA_LOCAL, i.src1.constant, i.src2);
+    e.vmovss(e.dword[e.rsp + i.src1.constant()], i.src2);
+  }
+};
+struct STORE_LOCAL_F64
+    : Sequence<STORE_LOCAL_F64, I<OPCODE_STORE_LOCAL, VoidOp, I32Op, F64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    // e.TraceStoreF64(DATA_LOCAL, i.src1.constant, i.src2);
+    e.vmovsd(e.qword[e.rsp + i.src1.constant()], i.src2);
+  }
+};
+struct STORE_LOCAL_V128
+    : Sequence<STORE_LOCAL_V128, I<OPCODE_STORE_LOCAL, VoidOp, I32Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    // e.TraceStoreV128(DATA_LOCAL, i.src1.constant, i.src2);
+    e.vmovaps(e.ptr[e.rsp + i.src1.constant()], i.src2);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_STORE_LOCAL, STORE_LOCAL_I8, STORE_LOCAL_I16,
+                     STORE_LOCAL_I32, STORE_LOCAL_I64, STORE_LOCAL_F32,
+                     STORE_LOCAL_F64, STORE_LOCAL_V128);
+
+// ============================================================================
+// OPCODE_LOAD_CONTEXT
+// ============================================================================
+struct LOAD_CONTEXT_I8
+    : Sequence<LOAD_CONTEXT_I8, I<OPCODE_LOAD_CONTEXT, I8Op, OffsetOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeContextAddress(e, i.src1);
+    e.mov(i.dest, e.byte[addr]);
+    if (IsTracingData()) {
+      e.mov(e.GetNativeParam(0), i.src1.value);
+      e.mov(e.GetNativeParam(1), e.byte[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceContextLoadI8));
+    }
+  }
+};
+struct LOAD_CONTEXT_I16
+    : Sequence<LOAD_CONTEXT_I16, I<OPCODE_LOAD_CONTEXT, I16Op, OffsetOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeContextAddress(e, i.src1);
+    e.mov(i.dest, e.word[addr]);
+    if (IsTracingData()) {
+      e.mov(e.GetNativeParam(1), e.word[addr]);
+      e.mov(e.GetNativeParam(0), i.src1.value);
+      e.CallNative(reinterpret_cast<void*>(TraceContextLoadI16));
+    }
+  }
+};
+struct LOAD_CONTEXT_I32
+    : Sequence<LOAD_CONTEXT_I32, I<OPCODE_LOAD_CONTEXT, I32Op, OffsetOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeContextAddress(e, i.src1);
+    e.mov(i.dest, e.dword[addr]);
+    if (IsTracingData()) {
+      e.mov(e.GetNativeParam(1), e.dword[addr]);
+      e.mov(e.GetNativeParam(0), i.src1.value);
+      e.CallNative(reinterpret_cast<void*>(TraceContextLoadI32));
+    }
+  }
+};
+struct LOAD_CONTEXT_I64
+    : Sequence<LOAD_CONTEXT_I64, I<OPCODE_LOAD_CONTEXT, I64Op, OffsetOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeContextAddress(e, i.src1);
+    e.mov(i.dest, e.qword[addr]);
+    if (IsTracingData()) {
+      e.mov(e.GetNativeParam(1), e.qword[addr]);
+      e.mov(e.GetNativeParam(0), i.src1.value);
+      e.CallNative(reinterpret_cast<void*>(TraceContextLoadI64));
+    }
+  }
+};
+struct LOAD_CONTEXT_F32
+    : Sequence<LOAD_CONTEXT_F32, I<OPCODE_LOAD_CONTEXT, F32Op, OffsetOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeContextAddress(e, i.src1);
+    e.vmovss(i.dest, e.dword[addr]);
+    if (IsTracingData()) {
+      e.lea(e.GetNativeParam(1), e.dword[addr]);
+      e.mov(e.GetNativeParam(0), i.src1.value);
+      e.CallNative(reinterpret_cast<void*>(TraceContextLoadF32));
+    }
+  }
+};
+struct LOAD_CONTEXT_F64
+    : Sequence<LOAD_CONTEXT_F64, I<OPCODE_LOAD_CONTEXT, F64Op, OffsetOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeContextAddress(e, i.src1);
+    e.vmovsd(i.dest, e.qword[addr]);
+    if (IsTracingData()) {
+      e.lea(e.GetNativeParam(1), e.qword[addr]);
+      e.mov(e.GetNativeParam(0), i.src1.value);
+      e.CallNative(reinterpret_cast<void*>(TraceContextLoadF64));
+    }
+  }
+};
+struct LOAD_CONTEXT_V128
+    : Sequence<LOAD_CONTEXT_V128, I<OPCODE_LOAD_CONTEXT, V128Op, OffsetOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeContextAddress(e, i.src1);
+    e.vmovaps(i.dest, e.ptr[addr]);
+    if (IsTracingData()) {
+      e.lea(e.GetNativeParam(1), e.ptr[addr]);
+      e.mov(e.GetNativeParam(0), i.src1.value);
+      e.CallNative(reinterpret_cast<void*>(TraceContextLoadV128));
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_LOAD_CONTEXT, LOAD_CONTEXT_I8, LOAD_CONTEXT_I16,
+                     LOAD_CONTEXT_I32, LOAD_CONTEXT_I64, LOAD_CONTEXT_F32,
+                     LOAD_CONTEXT_F64, LOAD_CONTEXT_V128);
+
+// ============================================================================
+// OPCODE_STORE_CONTEXT
+// ============================================================================
+// Note: all types are always aligned on the stack.
+struct STORE_CONTEXT_I8
+    : Sequence<STORE_CONTEXT_I8,
+               I<OPCODE_STORE_CONTEXT, VoidOp, OffsetOp, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeContextAddress(e, i.src1);
+    if (i.src2.is_constant) {
+      e.mov(e.byte[addr], i.src2.constant());
+    } else {
+      e.mov(e.byte[addr], i.src2);
+    }
+    if (IsTracingData()) {
+      e.mov(e.GetNativeParam(1), e.byte[addr]);
+      e.mov(e.GetNativeParam(0), i.src1.value);
+      e.CallNative(reinterpret_cast<void*>(TraceContextStoreI8));
+    }
+  }
+};
+struct STORE_CONTEXT_I16
+    : Sequence<STORE_CONTEXT_I16,
+               I<OPCODE_STORE_CONTEXT, VoidOp, OffsetOp, I16Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeContextAddress(e, i.src1);
+    if (i.src2.is_constant) {
+      e.mov(e.word[addr], i.src2.constant());
+    } else {
+      e.mov(e.word[addr], i.src2);
+    }
+    if (IsTracingData()) {
+      e.mov(e.GetNativeParam(1), e.word[addr]);
+      e.mov(e.GetNativeParam(0), i.src1.value);
+      e.CallNative(reinterpret_cast<void*>(TraceContextStoreI16));
+    }
+  }
+};
+struct STORE_CONTEXT_I32
+    : Sequence<STORE_CONTEXT_I32,
+               I<OPCODE_STORE_CONTEXT, VoidOp, OffsetOp, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeContextAddress(e, i.src1);
+    if (i.src2.is_constant) {
+      e.mov(e.dword[addr], i.src2.constant());
+    } else {
+      e.mov(e.dword[addr], i.src2);
+    }
+    if (IsTracingData()) {
+      e.mov(e.GetNativeParam(1), e.dword[addr]);
+      e.mov(e.GetNativeParam(0), i.src1.value);
+      e.CallNative(reinterpret_cast<void*>(TraceContextStoreI32));
+    }
+  }
+};
+struct STORE_CONTEXT_I64
+    : Sequence<STORE_CONTEXT_I64,
+               I<OPCODE_STORE_CONTEXT, VoidOp, OffsetOp, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeContextAddress(e, i.src1);
+    if (i.src2.is_constant) {
+      e.MovMem64(addr, i.src2.constant());
+    } else {
+      e.mov(e.qword[addr], i.src2);
+    }
+    if (IsTracingData()) {
+      e.mov(e.GetNativeParam(1), e.qword[addr]);
+      e.mov(e.GetNativeParam(0), i.src1.value);
+      e.CallNative(reinterpret_cast<void*>(TraceContextStoreI64));
+    }
+  }
+};
+struct STORE_CONTEXT_F32
+    : Sequence<STORE_CONTEXT_F32,
+               I<OPCODE_STORE_CONTEXT, VoidOp, OffsetOp, F32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeContextAddress(e, i.src1);
+    if (i.src2.is_constant) {
+      e.mov(e.dword[addr], i.src2.value->constant.i32);
+    } else {
+      e.vmovss(e.dword[addr], i.src2);
+    }
+    if (IsTracingData()) {
+      e.lea(e.GetNativeParam(1), e.dword[addr]);
+      e.mov(e.GetNativeParam(0), i.src1.value);
+      e.CallNative(reinterpret_cast<void*>(TraceContextStoreF32));
+    }
+  }
+};
+struct STORE_CONTEXT_F64
+    : Sequence<STORE_CONTEXT_F64,
+               I<OPCODE_STORE_CONTEXT, VoidOp, OffsetOp, F64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeContextAddress(e, i.src1);
+    if (i.src2.is_constant) {
+      e.MovMem64(addr, i.src2.value->constant.i64);
+    } else {
+      e.vmovsd(e.qword[addr], i.src2);
+    }
+    if (IsTracingData()) {
+      e.lea(e.GetNativeParam(1), e.qword[addr]);
+      e.mov(e.GetNativeParam(0), i.src1.value);
+      e.CallNative(reinterpret_cast<void*>(TraceContextStoreF64));
+    }
+  }
+};
+struct STORE_CONTEXT_V128
+    : Sequence<STORE_CONTEXT_V128,
+               I<OPCODE_STORE_CONTEXT, VoidOp, OffsetOp, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeContextAddress(e, i.src1);
+    if (i.src2.is_constant) {
+      e.LoadConstantXmm(e.xmm0, i.src2.constant());
+      e.vmovaps(e.ptr[addr], e.xmm0);
+    } else {
+      e.vmovaps(e.ptr[addr], i.src2);
+    }
+    if (IsTracingData()) {
+      e.lea(e.GetNativeParam(1), e.ptr[addr]);
+      e.mov(e.GetNativeParam(0), i.src1.value);
+      e.CallNative(reinterpret_cast<void*>(TraceContextStoreV128));
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_STORE_CONTEXT, STORE_CONTEXT_I8, STORE_CONTEXT_I16,
+                     STORE_CONTEXT_I32, STORE_CONTEXT_I64, STORE_CONTEXT_F32,
+                     STORE_CONTEXT_F64, STORE_CONTEXT_V128);
+
+// ============================================================================
+// OPCODE_LOAD_MMIO
+// ============================================================================
+// Note: all types are always aligned in the context.
+struct LOAD_MMIO_I32
+    : Sequence<LOAD_MMIO_I32, I<OPCODE_LOAD_MMIO, I32Op, OffsetOp, OffsetOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    // uint64_t (context, addr)
+    auto mmio_range = reinterpret_cast<MMIORange*>(i.src1.value);
+    auto read_address = uint32_t(i.src2.value);
+    e.mov(e.GetNativeParam(0), uint64_t(mmio_range->callback_context));
+    e.mov(e.GetNativeParam(1).cvt32(), read_address);
+    e.CallNativeSafe(reinterpret_cast<void*>(mmio_range->read));
+    e.bswap(e.eax);
+    e.mov(i.dest, e.eax);
+    if (IsTracingData()) {
+      e.mov(e.GetNativeParam(0), i.dest);
+      e.mov(e.edx, read_address);
+      e.CallNative(reinterpret_cast<void*>(TraceContextLoadI32));
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_LOAD_MMIO, LOAD_MMIO_I32);
+
+// ============================================================================
+// OPCODE_STORE_MMIO
+// ============================================================================
+// Note: all types are always aligned on the stack.
+struct STORE_MMIO_I32
+    : Sequence<STORE_MMIO_I32,
+               I<OPCODE_STORE_MMIO, VoidOp, OffsetOp, OffsetOp, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    // void (context, addr, value)
+    auto mmio_range = reinterpret_cast<MMIORange*>(i.src1.value);
+    auto write_address = uint32_t(i.src2.value);
+    e.mov(e.GetNativeParam(0), uint64_t(mmio_range->callback_context));
+    e.mov(e.GetNativeParam(1).cvt32(), write_address);
+    if (i.src3.is_constant) {
+      e.mov(e.GetNativeParam(2).cvt32(), xe::byte_swap(i.src3.constant()));
+    } else {
+      e.mov(e.GetNativeParam(2).cvt32(), i.src3);
+      e.bswap(e.GetNativeParam(2).cvt32());
+    }
+    e.CallNativeSafe(reinterpret_cast<void*>(mmio_range->write));
+    if (IsTracingData()) {
+      if (i.src3.is_constant) {
+        e.mov(e.GetNativeParam(0).cvt32(), i.src3.constant());
+      } else {
+        e.mov(e.GetNativeParam(0).cvt32(), i.src3);
+      }
+      e.mov(e.edx, write_address);
+      e.CallNative(reinterpret_cast<void*>(TraceContextStoreI32));
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_STORE_MMIO, STORE_MMIO_I32);
+
+// ============================================================================
+// OPCODE_LOAD_OFFSET
+// ============================================================================
+struct LOAD_OFFSET_I8
+    : Sequence<LOAD_OFFSET_I8, I<OPCODE_LOAD_OFFSET, I8Op, I64Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
+    e.mov(i.dest, e.byte[addr]);
+  }
+};
+
+struct LOAD_OFFSET_I16
+    : Sequence<LOAD_OFFSET_I16, I<OPCODE_LOAD_OFFSET, I16Op, I64Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
+        e.movbe(i.dest, e.word[addr]);
+      } else {
+        e.mov(i.dest, e.word[addr]);
+        e.ror(i.dest, 8);
+      }
+    } else {
+      e.mov(i.dest, e.word[addr]);
+    }
+  }
+};
+
+struct LOAD_OFFSET_I32
+    : Sequence<LOAD_OFFSET_I32, I<OPCODE_LOAD_OFFSET, I32Op, I64Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
+        e.movbe(i.dest, e.dword[addr]);
+      } else {
+        e.mov(i.dest, e.dword[addr]);
+        e.bswap(i.dest);
+      }
+    } else {
+      e.mov(i.dest, e.dword[addr]);
+    }
+  }
+};
+
+struct LOAD_OFFSET_I64
+    : Sequence<LOAD_OFFSET_I64, I<OPCODE_LOAD_OFFSET, I64Op, I64Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
+        e.movbe(i.dest, e.qword[addr]);
+      } else {
+        e.mov(i.dest, e.qword[addr]);
+        e.bswap(i.dest);
+      }
+    } else {
+      e.mov(i.dest, e.qword[addr]);
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_LOAD_OFFSET, LOAD_OFFSET_I8, LOAD_OFFSET_I16,
+                     LOAD_OFFSET_I32, LOAD_OFFSET_I64);
+
+// ============================================================================
+// OPCODE_STORE_OFFSET
+// ============================================================================
+struct STORE_OFFSET_I8
+    : Sequence<STORE_OFFSET_I8,
+               I<OPCODE_STORE_OFFSET, VoidOp, I64Op, I64Op, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
+    if (i.src3.is_constant) {
+      e.mov(e.byte[addr], i.src3.constant());
+    } else {
+      e.mov(e.byte[addr], i.src3);
+    }
+  }
+};
+
+struct STORE_OFFSET_I16
+    : Sequence<STORE_OFFSET_I16,
+               I<OPCODE_STORE_OFFSET, VoidOp, I64Op, I64Op, I16Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      assert_false(i.src3.is_constant);
+      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
+        e.movbe(e.word[addr], i.src3);
+      } else {
+        assert_always("not implemented");
+      }
+    } else {
+      if (i.src3.is_constant) {
+        e.mov(e.word[addr], i.src3.constant());
+      } else {
+        e.mov(e.word[addr], i.src3);
+      }
+    }
+  }
+};
+
+struct STORE_OFFSET_I32
+    : Sequence<STORE_OFFSET_I32,
+               I<OPCODE_STORE_OFFSET, VoidOp, I64Op, I64Op, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      assert_false(i.src3.is_constant);
+      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
+        e.movbe(e.dword[addr], i.src3);
+      } else {
+        assert_always("not implemented");
+      }
+    } else {
+      if (i.src3.is_constant) {
+        e.mov(e.dword[addr], i.src3.constant());
+      } else {
+        e.mov(e.dword[addr], i.src3);
+      }
+    }
+  }
+};
+
+struct STORE_OFFSET_I64
+    : Sequence<STORE_OFFSET_I64,
+               I<OPCODE_STORE_OFFSET, VoidOp, I64Op, I64Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      assert_false(i.src3.is_constant);
+      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
+        e.movbe(e.qword[addr], i.src3);
+      } else {
+        assert_always("not implemented");
+      }
+    } else {
+      if (i.src3.is_constant) {
+        e.MovMem64(addr, i.src3.constant());
+      } else {
+        e.mov(e.qword[addr], i.src3);
+      }
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_STORE_OFFSET, STORE_OFFSET_I8, STORE_OFFSET_I16,
+                     STORE_OFFSET_I32, STORE_OFFSET_I64);
+
+// ============================================================================
+// OPCODE_LOAD
+// ============================================================================
+struct LOAD_I8 : Sequence<LOAD_I8, I<OPCODE_LOAD, I8Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    e.mov(i.dest, e.byte[addr]);
+    if (IsTracingData()) {
+      e.mov(e.GetNativeParam(1).cvt8(), i.dest);
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemoryLoadI8));
+    }
+  }
+};
+struct LOAD_I16 : Sequence<LOAD_I16, I<OPCODE_LOAD, I16Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
+        e.movbe(i.dest, e.word[addr]);
+      } else {
+        e.mov(i.dest, e.word[addr]);
+        e.ror(i.dest, 8);
+      }
+    } else {
+      e.mov(i.dest, e.word[addr]);
+    }
+    if (IsTracingData()) {
+      e.mov(e.GetNativeParam(1).cvt16(), i.dest);
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemoryLoadI16));
+    }
+  }
+};
+struct LOAD_I32 : Sequence<LOAD_I32, I<OPCODE_LOAD, I32Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
+        e.movbe(i.dest, e.dword[addr]);
+      } else {
+        e.mov(i.dest, e.dword[addr]);
+        e.bswap(i.dest);
+      }
+    } else {
+      e.mov(i.dest, e.dword[addr]);
+    }
+    if (IsTracingData()) {
+      e.mov(e.GetNativeParam(1).cvt32(), i.dest);
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemoryLoadI32));
+    }
+  }
+};
+struct LOAD_I64 : Sequence<LOAD_I64, I<OPCODE_LOAD, I64Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
+        e.movbe(i.dest, e.qword[addr]);
+      } else {
+        e.mov(i.dest, e.qword[addr]);
+        e.bswap(i.dest);
+      }
+    } else {
+      e.mov(i.dest, e.qword[addr]);
+    }
+    if (IsTracingData()) {
+      e.mov(e.GetNativeParam(1), i.dest);
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemoryLoadI64));
+    }
+  }
+};
+struct LOAD_F32 : Sequence<LOAD_F32, I<OPCODE_LOAD, F32Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    e.vmovss(i.dest, e.dword[addr]);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      assert_always("not implemented yet");
+    }
+    if (IsTracingData()) {
+      e.lea(e.GetNativeParam(1), e.dword[addr]);
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemoryLoadF32));
+    }
+  }
+};
+struct LOAD_F64 : Sequence<LOAD_F64, I<OPCODE_LOAD, F64Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    e.vmovsd(i.dest, e.qword[addr]);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      assert_always("not implemented yet");
+    }
+    if (IsTracingData()) {
+      e.lea(e.GetNativeParam(1), e.qword[addr]);
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemoryLoadF64));
+    }
+  }
+};
+struct LOAD_V128 : Sequence<LOAD_V128, I<OPCODE_LOAD, V128Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    // TODO(benvanik): we should try to stick to movaps if possible.
+    e.vmovups(i.dest, e.ptr[addr]);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      // TODO(benvanik): find a way to do this without the memory load.
+      e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMByteSwapMask));
+    }
+    if (IsTracingData()) {
+      e.lea(e.GetNativeParam(1), e.ptr[addr]);
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemoryLoadV128));
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_LOAD, LOAD_I8, LOAD_I16, LOAD_I32, LOAD_I64,
+                     LOAD_F32, LOAD_F64, LOAD_V128);
+
+// ============================================================================
+// OPCODE_STORE
+// ============================================================================
+// Note: most *should* be aligned, but needs to be checked!
+struct STORE_I8 : Sequence<STORE_I8, I<OPCODE_STORE, VoidOp, I64Op, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    if (i.src2.is_constant) {
+      e.mov(e.byte[addr], i.src2.constant());
+    } else {
+      e.mov(e.byte[addr], i.src2);
+    }
+    if (IsTracingData()) {
+      addr = ComputeMemoryAddress(e, i.src1);
+      e.mov(e.GetNativeParam(1).cvt8(), e.byte[addr]);
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemoryStoreI8));
+    }
+  }
+};
+struct STORE_I16 : Sequence<STORE_I16, I<OPCODE_STORE, VoidOp, I64Op, I16Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      assert_false(i.src2.is_constant);
+      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
+        e.movbe(e.word[addr], i.src2);
+      } else {
+        assert_always("not implemented");
+      }
+    } else {
+      if (i.src2.is_constant) {
+        e.mov(e.word[addr], i.src2.constant());
+      } else {
+        e.mov(e.word[addr], i.src2);
+      }
+    }
+    if (IsTracingData()) {
+      addr = ComputeMemoryAddress(e, i.src1);
+      e.mov(e.GetNativeParam(1).cvt16(), e.word[addr]);
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemoryStoreI16));
+    }
+  }
+};
+struct STORE_I32 : Sequence<STORE_I32, I<OPCODE_STORE, VoidOp, I64Op, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      assert_false(i.src2.is_constant);
+      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
+        e.movbe(e.dword[addr], i.src2);
+      } else {
+        assert_always("not implemented");
+      }
+    } else {
+      if (i.src2.is_constant) {
+        e.mov(e.dword[addr], i.src2.constant());
+      } else {
+        e.mov(e.dword[addr], i.src2);
+      }
+    }
+    if (IsTracingData()) {
+      addr = ComputeMemoryAddress(e, i.src1);
+      e.mov(e.GetNativeParam(1).cvt32(), e.dword[addr]);
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemoryStoreI32));
+    }
+  }
+};
+struct STORE_I64 : Sequence<STORE_I64, I<OPCODE_STORE, VoidOp, I64Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      assert_false(i.src2.is_constant);
+      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
+        e.movbe(e.qword[addr], i.src2);
+      } else {
+        assert_always("not implemented");
+      }
+    } else {
+      if (i.src2.is_constant) {
+        e.MovMem64(addr, i.src2.constant());
+      } else {
+        e.mov(e.qword[addr], i.src2);
+      }
+    }
+    if (IsTracingData()) {
+      addr = ComputeMemoryAddress(e, i.src1);
+      e.mov(e.GetNativeParam(1), e.qword[addr]);
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemoryStoreI64));
+    }
+  }
+};
+struct STORE_F32 : Sequence<STORE_F32, I<OPCODE_STORE, VoidOp, I64Op, F32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      assert_false(i.src2.is_constant);
+      assert_always("not yet implemented");
+    } else {
+      if (i.src2.is_constant) {
+        e.mov(e.dword[addr], i.src2.value->constant.i32);
+      } else {
+        e.vmovss(e.dword[addr], i.src2);
+      }
+    }
+    if (IsTracingData()) {
+      addr = ComputeMemoryAddress(e, i.src1);
+      e.lea(e.GetNativeParam(1), e.ptr[addr]);
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemoryStoreF32));
+    }
+  }
+};
+struct STORE_F64 : Sequence<STORE_F64, I<OPCODE_STORE, VoidOp, I64Op, F64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      assert_false(i.src2.is_constant);
+      assert_always("not yet implemented");
+    } else {
+      if (i.src2.is_constant) {
+        e.MovMem64(addr, i.src2.value->constant.i64);
+      } else {
+        e.vmovsd(e.qword[addr], i.src2);
+      }
+    }
+    if (IsTracingData()) {
+      addr = ComputeMemoryAddress(e, i.src1);
+      e.lea(e.GetNativeParam(1), e.ptr[addr]);
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemoryStoreF64));
+    }
+  }
+};
+struct STORE_V128
+    : Sequence<STORE_V128, I<OPCODE_STORE, VoidOp, I64Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
+      assert_false(i.src2.is_constant);
+      e.vpshufb(e.xmm0, i.src2, e.GetXmmConstPtr(XMMByteSwapMask));
+      e.vmovaps(e.ptr[addr], e.xmm0);
+    } else {
+      if (i.src2.is_constant) {
+        e.LoadConstantXmm(e.xmm0, i.src2.constant());
+        e.vmovaps(e.ptr[addr], e.xmm0);
+      } else {
+        e.vmovaps(e.ptr[addr], i.src2);
+      }
+    }
+    if (IsTracingData()) {
+      addr = ComputeMemoryAddress(e, i.src1);
+      e.lea(e.GetNativeParam(1), e.ptr[addr]);
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemoryStoreV128));
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_STORE, STORE_I8, STORE_I16, STORE_I32, STORE_I64,
+                     STORE_F32, STORE_F64, STORE_V128);
+
+// ============================================================================
+// OPCODE_PREFETCH
+// ============================================================================
+struct PREFETCH
+    : Sequence<PREFETCH, I<OPCODE_PREFETCH, VoidOp, I64Op, OffsetOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    // TODO(benvanik): prefetch addr -> length.
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_PREFETCH, PREFETCH);
+
+// ============================================================================
+// OPCODE_MEMORY_BARRIER
+// ============================================================================
+struct MEMORY_BARRIER
+    : Sequence<MEMORY_BARRIER, I<OPCODE_MEMORY_BARRIER, VoidOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) { e.mfence(); }
+};
+EMITTER_OPCODE_TABLE(OPCODE_MEMORY_BARRIER, MEMORY_BARRIER);
+
+// ============================================================================
+// OPCODE_MEMSET
+// ============================================================================
+struct MEMSET_I64_I8_I64
+    : Sequence<MEMSET_I64_I8_I64,
+               I<OPCODE_MEMSET, VoidOp, I64Op, I8Op, I64Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.is_constant);
+    assert_true(i.src3.is_constant);
+    assert_true(i.src2.constant() == 0);
+    e.vpxor(e.xmm0, e.xmm0);
+    auto addr = ComputeMemoryAddress(e, i.src1);
+    switch (i.src3.constant()) {
+      case 32:
+        e.vmovaps(e.ptr[addr + 0 * 16], e.xmm0);
+        e.vmovaps(e.ptr[addr + 1 * 16], e.xmm0);
+        break;
+      case 128:
+        e.vmovaps(e.ptr[addr + 0 * 16], e.xmm0);
+        e.vmovaps(e.ptr[addr + 1 * 16], e.xmm0);
+        e.vmovaps(e.ptr[addr + 2 * 16], e.xmm0);
+        e.vmovaps(e.ptr[addr + 3 * 16], e.xmm0);
+        e.vmovaps(e.ptr[addr + 4 * 16], e.xmm0);
+        e.vmovaps(e.ptr[addr + 5 * 16], e.xmm0);
+        e.vmovaps(e.ptr[addr + 6 * 16], e.xmm0);
+        e.vmovaps(e.ptr[addr + 7 * 16], e.xmm0);
+        break;
+      default:
+        assert_unhandled_case(i.src3.constant());
+        break;
+    }
+    if (IsTracingData()) {
+      addr = ComputeMemoryAddress(e, i.src1);
+      e.mov(e.GetNativeParam(2), i.src3.constant());
+      e.mov(e.GetNativeParam(1), i.src2.constant());
+      e.lea(e.GetNativeParam(0), e.ptr[addr]);
+      e.CallNative(reinterpret_cast<void*>(TraceMemset));
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_MEMSET, MEMSET_I64_I8_I64);
+
+}  // namespace x64
+}  // namespace backend
+}  // namespace cpu
+}  // namespace xe
diff --git a/src/xenia/cpu/backend/x64/x64_seq_vector.cc b/src/xenia/cpu/backend/x64/x64_seq_vector.cc
new file mode 100644
index 000000000..0d1a0de33
--- /dev/null
+++ b/src/xenia/cpu/backend/x64/x64_seq_vector.cc
@@ -0,0 +1,2556 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2018 Xenia Developers. All rights reserved.                      *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "xenia/cpu/backend/x64/x64_sequences.h"
+
+#include <algorithm>
+#include <cstring>
+
+#include "xenia/cpu/backend/x64/x64_op.h"
+
+// For OPCODE_PACK/OPCODE_UNPACK
+#include "third_party/half/include/half.hpp"
+
+namespace xe {
+namespace cpu {
+namespace backend {
+namespace x64 {
+
+volatile int anchor_vector = 0;
+
+// ============================================================================
+// OPCODE_VECTOR_CONVERT_I2F
+// ============================================================================
+struct VECTOR_CONVERT_I2F
+    : Sequence<VECTOR_CONVERT_I2F,
+               I<OPCODE_VECTOR_CONVERT_I2F, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    // flags = ARITHMETIC_UNSIGNED
+    if (i.instr->flags & ARITHMETIC_UNSIGNED) {
+      // xmm0 = mask of positive values
+      e.vpcmpgtd(e.xmm0, i.src1, e.GetXmmConstPtr(XMMFFFF));
+
+      // scale any values >= (unsigned)INT_MIN back to [0, INT_MAX]
+      e.vpsubd(e.xmm1, i.src1, e.GetXmmConstPtr(XMMSignMaskI32));
+      e.vblendvps(e.xmm1, e.xmm1, i.src1, e.xmm0);
+
+      // xmm1 = [0, INT_MAX]
+      e.vcvtdq2ps(i.dest, e.xmm1);
+
+      // scale values back above [INT_MIN, UINT_MAX]
+      e.vpandn(e.xmm0, e.xmm0, e.GetXmmConstPtr(XMMPosIntMinPS));
+      e.vaddps(i.dest, i.dest, e.xmm0);
+    } else {
+      e.vcvtdq2ps(i.dest, i.src1);
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_CONVERT_I2F, VECTOR_CONVERT_I2F);
+
+// ============================================================================
+// OPCODE_VECTOR_CONVERT_F2I
+// ============================================================================
+struct VECTOR_CONVERT_F2I
+    : Sequence<VECTOR_CONVERT_F2I,
+               I<OPCODE_VECTOR_CONVERT_F2I, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    if (i.instr->flags & ARITHMETIC_UNSIGNED) {
+      // clamp to min 0
+      e.vmaxps(e.xmm0, i.src1, e.GetXmmConstPtr(XMMZero));
+
+      // xmm1 = mask of values >= (unsigned)INT_MIN
+      e.vcmpgeps(e.xmm1, e.xmm0, e.GetXmmConstPtr(XMMPosIntMinPS));
+
+      // scale any values >= (unsigned)INT_MIN back to [0, ...]
+      e.vsubps(e.xmm2, e.xmm0, e.GetXmmConstPtr(XMMPosIntMinPS));
+      e.vblendvps(e.xmm0, e.xmm0, e.xmm2, e.xmm1);
+
+      // xmm0 = [0, INT_MAX]
+      // this may still contain values > INT_MAX (if src has vals > UINT_MAX)
+      e.vcvttps2dq(i.dest, e.xmm0);
+
+      // xmm0 = mask of values that need saturation
+      e.vpcmpeqd(e.xmm0, i.dest, e.GetXmmConstPtr(XMMIntMin));
+
+      // scale values back above [INT_MIN, UINT_MAX]
+      e.vpand(e.xmm1, e.xmm1, e.GetXmmConstPtr(XMMIntMin));
+      e.vpaddd(i.dest, i.dest, e.xmm1);
+
+      // saturate values > UINT_MAX
+      e.vpor(i.dest, i.dest, e.xmm0);
+    } else {
+      // xmm2 = NaN mask
+      e.vcmpunordps(e.xmm2, i.src1, i.src1);
+
+      // convert packed floats to packed dwords
+      e.vcvttps2dq(e.xmm0, i.src1);
+
+      // (high bit) xmm1 = dest is indeterminate and i.src1 >= 0
+      e.vpcmpeqd(e.xmm1, e.xmm0, e.GetXmmConstPtr(XMMIntMin));
+      e.vpandn(e.xmm1, i.src1, e.xmm1);
+
+      // saturate positive values
+      e.vblendvps(i.dest, e.xmm0, e.GetXmmConstPtr(XMMIntMax), e.xmm1);
+
+      // mask NaNs
+      e.vpandn(i.dest, e.xmm2, i.dest);
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_CONVERT_F2I, VECTOR_CONVERT_F2I);
+
+// ============================================================================
+// OPCODE_LOAD_VECTOR_SHL
+// ============================================================================
+static const vec128_t lvsl_table[16] = {
+    vec128b(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15),
+    vec128b(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
+    vec128b(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17),
+    vec128b(3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18),
+    vec128b(4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19),
+    vec128b(5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20),
+    vec128b(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21),
+    vec128b(7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22),
+    vec128b(8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23),
+    vec128b(9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24),
+    vec128b(10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25),
+    vec128b(11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26),
+    vec128b(12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27),
+    vec128b(13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28),
+    vec128b(14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29),
+    vec128b(15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30),
+};
+struct LOAD_VECTOR_SHL_I8
+    : Sequence<LOAD_VECTOR_SHL_I8, I<OPCODE_LOAD_VECTOR_SHL, V128Op, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    if (i.src1.is_constant) {
+      auto sh = i.src1.constant();
+      assert_true(sh < xe::countof(lvsl_table));
+      e.mov(e.rax, (uintptr_t)&lvsl_table[sh]);
+      e.vmovaps(i.dest, e.ptr[e.rax]);
+    } else {
+      // TODO(benvanik): find a cheaper way of doing this.
+      e.movzx(e.rdx, i.src1);
+      e.and_(e.dx, 0xF);
+      e.shl(e.dx, 4);
+      e.mov(e.rax, (uintptr_t)lvsl_table);
+      e.vmovaps(i.dest, e.ptr[e.rax + e.rdx]);
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_LOAD_VECTOR_SHL, LOAD_VECTOR_SHL_I8);
+
+// ============================================================================
+// OPCODE_LOAD_VECTOR_SHR
+// ============================================================================
+static const vec128_t lvsr_table[16] = {
+    vec128b(16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31),
+    vec128b(15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30),
+    vec128b(14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29),
+    vec128b(13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28),
+    vec128b(12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27),
+    vec128b(11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26),
+    vec128b(10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25),
+    vec128b(9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24),
+    vec128b(8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23),
+    vec128b(7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22),
+    vec128b(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21),
+    vec128b(5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20),
+    vec128b(4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19),
+    vec128b(3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18),
+    vec128b(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17),
+    vec128b(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
+};
+struct LOAD_VECTOR_SHR_I8
+    : Sequence<LOAD_VECTOR_SHR_I8, I<OPCODE_LOAD_VECTOR_SHR, V128Op, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    if (i.src1.is_constant) {
+      auto sh = i.src1.constant();
+      assert_true(sh < xe::countof(lvsr_table));
+      e.mov(e.rax, (uintptr_t)&lvsr_table[sh]);
+      e.vmovaps(i.dest, e.ptr[e.rax]);
+    } else {
+      // TODO(benvanik): find a cheaper way of doing this.
+      e.movzx(e.rdx, i.src1);
+      e.and_(e.dx, 0xF);
+      e.shl(e.dx, 4);
+      e.mov(e.rax, (uintptr_t)lvsr_table);
+      e.vmovaps(i.dest, e.ptr[e.rax + e.rdx]);
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_LOAD_VECTOR_SHR, LOAD_VECTOR_SHR_I8);
+
+// ============================================================================
+// OPCODE_VECTOR_MAX
+// ============================================================================
+struct VECTOR_MAX
+    : Sequence<VECTOR_MAX, I<OPCODE_VECTOR_MAX, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    EmitCommutativeBinaryXmmOp(
+        e, i, [&i](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) {
+          uint32_t part_type = i.instr->flags >> 8;
+          if (i.instr->flags & ARITHMETIC_UNSIGNED) {
+            switch (part_type) {
+              case INT8_TYPE:
+                e.vpmaxub(dest, src1, src2);
+                break;
+              case INT16_TYPE:
+                e.vpmaxuw(dest, src1, src2);
+                break;
+              case INT32_TYPE:
+                e.vpmaxud(dest, src1, src2);
+                break;
+              default:
+                assert_unhandled_case(part_type);
+                break;
+            }
+          } else {
+            switch (part_type) {
+              case INT8_TYPE:
+                e.vpmaxsb(dest, src1, src2);
+                break;
+              case INT16_TYPE:
+                e.vpmaxsw(dest, src1, src2);
+                break;
+              case INT32_TYPE:
+                e.vpmaxsd(dest, src1, src2);
+                break;
+              default:
+                assert_unhandled_case(part_type);
+                break;
+            }
+          }
+        });
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_MAX, VECTOR_MAX);
+
+// ============================================================================
+// OPCODE_VECTOR_MIN
+// ============================================================================
+struct VECTOR_MIN
+    : Sequence<VECTOR_MIN, I<OPCODE_VECTOR_MIN, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    EmitCommutativeBinaryXmmOp(
+        e, i, [&i](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) {
+          uint32_t part_type = i.instr->flags >> 8;
+          if (i.instr->flags & ARITHMETIC_UNSIGNED) {
+            switch (part_type) {
+              case INT8_TYPE:
+                e.vpminub(dest, src1, src2);
+                break;
+              case INT16_TYPE:
+                e.vpminuw(dest, src1, src2);
+                break;
+              case INT32_TYPE:
+                e.vpminud(dest, src1, src2);
+                break;
+              default:
+                assert_unhandled_case(part_type);
+                break;
+            }
+          } else {
+            switch (part_type) {
+              case INT8_TYPE:
+                e.vpminsb(dest, src1, src2);
+                break;
+              case INT16_TYPE:
+                e.vpminsw(dest, src1, src2);
+                break;
+              case INT32_TYPE:
+                e.vpminsd(dest, src1, src2);
+                break;
+              default:
+                assert_unhandled_case(part_type);
+                break;
+            }
+          }
+        });
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_MIN, VECTOR_MIN);
+
+// ============================================================================
+// OPCODE_VECTOR_COMPARE_EQ
+// ============================================================================
+struct VECTOR_COMPARE_EQ_V128
+    : Sequence<VECTOR_COMPARE_EQ_V128,
+               I<OPCODE_VECTOR_COMPARE_EQ, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    EmitCommutativeBinaryXmmOp(
+        e, i, [&i](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) {
+          switch (i.instr->flags) {
+            case INT8_TYPE:
+              e.vpcmpeqb(dest, src1, src2);
+              break;
+            case INT16_TYPE:
+              e.vpcmpeqw(dest, src1, src2);
+              break;
+            case INT32_TYPE:
+              e.vpcmpeqd(dest, src1, src2);
+              break;
+            case FLOAT32_TYPE:
+              e.vcmpeqps(dest, src1, src2);
+              break;
+          }
+        });
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_COMPARE_EQ, VECTOR_COMPARE_EQ_V128);
+
+// ============================================================================
+// OPCODE_VECTOR_COMPARE_SGT
+// ============================================================================
+struct VECTOR_COMPARE_SGT_V128
+    : Sequence<VECTOR_COMPARE_SGT_V128,
+               I<OPCODE_VECTOR_COMPARE_SGT, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    EmitAssociativeBinaryXmmOp(
+        e, i, [&i](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) {
+          switch (i.instr->flags) {
+            case INT8_TYPE:
+              e.vpcmpgtb(dest, src1, src2);
+              break;
+            case INT16_TYPE:
+              e.vpcmpgtw(dest, src1, src2);
+              break;
+            case INT32_TYPE:
+              e.vpcmpgtd(dest, src1, src2);
+              break;
+            case FLOAT32_TYPE:
+              e.vcmpgtps(dest, src1, src2);
+              break;
+          }
+        });
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_COMPARE_SGT, VECTOR_COMPARE_SGT_V128);
+
+// ============================================================================
+// OPCODE_VECTOR_COMPARE_SGE
+// ============================================================================
+struct VECTOR_COMPARE_SGE_V128
+    : Sequence<VECTOR_COMPARE_SGE_V128,
+               I<OPCODE_VECTOR_COMPARE_SGE, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    EmitAssociativeBinaryXmmOp(
+        e, i, [&i](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) {
+          switch (i.instr->flags) {
+            case INT8_TYPE:
+              e.vpcmpeqb(e.xmm0, src1, src2);
+              e.vpcmpgtb(dest, src1, src2);
+              e.vpor(dest, e.xmm0);
+              break;
+            case INT16_TYPE:
+              e.vpcmpeqw(e.xmm0, src1, src2);
+              e.vpcmpgtw(dest, src1, src2);
+              e.vpor(dest, e.xmm0);
+              break;
+            case INT32_TYPE:
+              e.vpcmpeqd(e.xmm0, src1, src2);
+              e.vpcmpgtd(dest, src1, src2);
+              e.vpor(dest, e.xmm0);
+              break;
+            case FLOAT32_TYPE:
+              e.vcmpgeps(dest, src1, src2);
+              break;
+          }
+        });
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_COMPARE_SGE, VECTOR_COMPARE_SGE_V128);
+
+// ============================================================================
+// OPCODE_VECTOR_COMPARE_UGT
+// ============================================================================
+struct VECTOR_COMPARE_UGT_V128
+    : Sequence<VECTOR_COMPARE_UGT_V128,
+               I<OPCODE_VECTOR_COMPARE_UGT, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    Xbyak::Address sign_addr = e.ptr[e.rax];  // dummy
+    switch (i.instr->flags) {
+      case INT8_TYPE:
+        sign_addr = e.GetXmmConstPtr(XMMSignMaskI8);
+        break;
+      case INT16_TYPE:
+        sign_addr = e.GetXmmConstPtr(XMMSignMaskI16);
+        break;
+      case INT32_TYPE:
+        sign_addr = e.GetXmmConstPtr(XMMSignMaskI32);
+        break;
+      case FLOAT32_TYPE:
+        sign_addr = e.GetXmmConstPtr(XMMSignMaskF32);
+        break;
+      default:
+        assert_always();
+        break;
+    }
+    if (i.src1.is_constant) {
+      // TODO(benvanik): make this constant.
+      e.LoadConstantXmm(e.xmm0, i.src1.constant());
+      e.vpxor(e.xmm0, sign_addr);
+    } else {
+      e.vpxor(e.xmm0, i.src1, sign_addr);
+    }
+    if (i.src2.is_constant) {
+      // TODO(benvanik): make this constant.
+      e.LoadConstantXmm(e.xmm1, i.src2.constant());
+      e.vpxor(e.xmm1, sign_addr);
+    } else {
+      e.vpxor(e.xmm1, i.src2, sign_addr);
+    }
+    switch (i.instr->flags) {
+      case INT8_TYPE:
+        e.vpcmpgtb(i.dest, e.xmm0, e.xmm1);
+        break;
+      case INT16_TYPE:
+        e.vpcmpgtw(i.dest, e.xmm0, e.xmm1);
+        break;
+      case INT32_TYPE:
+        e.vpcmpgtd(i.dest, e.xmm0, e.xmm1);
+        break;
+      case FLOAT32_TYPE:
+        e.vcmpgtps(i.dest, e.xmm0, e.xmm1);
+        break;
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_COMPARE_UGT, VECTOR_COMPARE_UGT_V128);
+
+// ============================================================================
+// OPCODE_VECTOR_COMPARE_UGE
+// ============================================================================
+struct VECTOR_COMPARE_UGE_V128
+    : Sequence<VECTOR_COMPARE_UGE_V128,
+               I<OPCODE_VECTOR_COMPARE_UGE, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    Xbyak::Address sign_addr = e.ptr[e.rax];  // dummy
+    switch (i.instr->flags) {
+      case INT8_TYPE:
+        sign_addr = e.GetXmmConstPtr(XMMSignMaskI8);
+        break;
+      case INT16_TYPE:
+        sign_addr = e.GetXmmConstPtr(XMMSignMaskI16);
+        break;
+      case INT32_TYPE:
+        sign_addr = e.GetXmmConstPtr(XMMSignMaskI32);
+        break;
+      case FLOAT32_TYPE:
+        sign_addr = e.GetXmmConstPtr(XMMSignMaskF32);
+        break;
+    }
+    if (i.src1.is_constant) {
+      // TODO(benvanik): make this constant.
+      e.LoadConstantXmm(e.xmm0, i.src1.constant());
+      e.vpxor(e.xmm0, sign_addr);
+    } else {
+      e.vpxor(e.xmm0, i.src1, sign_addr);
+    }
+    if (i.src2.is_constant) {
+      // TODO(benvanik): make this constant.
+      e.LoadConstantXmm(e.xmm1, i.src2.constant());
+      e.vpxor(e.xmm1, sign_addr);
+    } else {
+      e.vpxor(e.xmm1, i.src2, sign_addr);
+    }
+    switch (i.instr->flags) {
+      case INT8_TYPE:
+        e.vpcmpeqb(e.xmm2, e.xmm0, e.xmm1);
+        e.vpcmpgtb(i.dest, e.xmm0, e.xmm1);
+        e.vpor(i.dest, e.xmm2);
+        break;
+      case INT16_TYPE:
+        e.vpcmpeqw(e.xmm2, e.xmm0, e.xmm1);
+        e.vpcmpgtw(i.dest, e.xmm0, e.xmm1);
+        e.vpor(i.dest, e.xmm2);
+        break;
+      case INT32_TYPE:
+        e.vpcmpeqd(e.xmm2, e.xmm0, e.xmm1);
+        e.vpcmpgtd(i.dest, e.xmm0, e.xmm1);
+        e.vpor(i.dest, e.xmm2);
+        break;
+      case FLOAT32_TYPE:
+        e.vcmpgeps(i.dest, e.xmm0, e.xmm1);
+        break;
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_COMPARE_UGE, VECTOR_COMPARE_UGE_V128);
+
+// ============================================================================
+// OPCODE_VECTOR_ADD
+// ============================================================================
+struct VECTOR_ADD
+    : Sequence<VECTOR_ADD, I<OPCODE_VECTOR_ADD, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    EmitCommutativeBinaryXmmOp(
+        e, i, [&i](X64Emitter& e, const Xmm& dest, Xmm src1, Xmm src2) {
+          const TypeName part_type =
+              static_cast<TypeName>(i.instr->flags & 0xFF);
+          const uint32_t arithmetic_flags = i.instr->flags >> 8;
+          bool is_unsigned = !!(arithmetic_flags & ARITHMETIC_UNSIGNED);
+          bool saturate = !!(arithmetic_flags & ARITHMETIC_SATURATE);
+          switch (part_type) {
+            case INT8_TYPE:
+              if (saturate) {
+                // TODO(benvanik): trace DID_SATURATE
+                if (is_unsigned) {
+                  e.vpaddusb(dest, src1, src2);
+                } else {
+                  e.vpaddsb(dest, src1, src2);
+                }
+              } else {
+                e.vpaddb(dest, src1, src2);
+              }
+              break;
+            case INT16_TYPE:
+              if (saturate) {
+                // TODO(benvanik): trace DID_SATURATE
+                if (is_unsigned) {
+                  e.vpaddusw(dest, src1, src2);
+                } else {
+                  e.vpaddsw(dest, src1, src2);
+                }
+              } else {
+                e.vpaddw(dest, src1, src2);
+              }
+              break;
+            case INT32_TYPE:
+              if (saturate) {
+                if (is_unsigned) {
+                  // xmm0 is the only temp register that can be used by
+                  // src1/src2.
+                  e.vpaddd(e.xmm1, src1, src2);
+
+                  // If result is smaller than either of the inputs, we've
+                  // overflowed (only need to check one input)
+                  // if (src1 > res) then overflowed
+                  // http://locklessinc.com/articles/sat_arithmetic/
+                  e.vpxor(e.xmm2, src1, e.GetXmmConstPtr(XMMSignMaskI32));
+                  e.vpxor(e.xmm0, e.xmm1, e.GetXmmConstPtr(XMMSignMaskI32));
+                  e.vpcmpgtd(e.xmm0, e.xmm2, e.xmm0);
+                  e.vpor(dest, e.xmm1, e.xmm0);
+                } else {
+                  e.vpaddd(e.xmm1, src1, src2);
+
+                  // Overflow results if two inputs are the same sign and the
+                  // result isn't the same sign. if ((s32b)(~(src1 ^ src2) &
+                  // (src1 ^ res)) < 0) then overflowed
+                  // http://locklessinc.com/articles/sat_arithmetic/
+                  e.vpxor(e.xmm2, src1, src2);
+                  e.vpxor(e.xmm3, src1, e.xmm1);
+                  e.vpandn(e.xmm2, e.xmm2, e.xmm3);
+
+                  // Set any negative overflowed elements of src1 to INT_MIN
+                  e.vpand(e.xmm3, src1, e.xmm2);
+                  e.vblendvps(e.xmm1, e.xmm1, e.GetXmmConstPtr(XMMSignMaskI32),
+                              e.xmm3);
+
+                  // Set any positive overflowed elements of src1 to INT_MAX
+                  e.vpandn(e.xmm3, src1, e.xmm2);
+                  e.vblendvps(dest, e.xmm1, e.GetXmmConstPtr(XMMAbsMaskPS),
+                              e.xmm3);
+                }
+              } else {
+                e.vpaddd(dest, src1, src2);
+              }
+              break;
+            case FLOAT32_TYPE:
+              assert_false(is_unsigned);
+              assert_false(saturate);
+              e.vaddps(dest, src1, src2);
+              break;
+            default:
+              assert_unhandled_case(part_type);
+              break;
+          }
+        });
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_ADD, VECTOR_ADD);
+
+// ============================================================================
+// OPCODE_VECTOR_SUB
+// ============================================================================
+struct VECTOR_SUB
+    : Sequence<VECTOR_SUB, I<OPCODE_VECTOR_SUB, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    EmitCommutativeBinaryXmmOp(
+        e, i, [&i](X64Emitter& e, const Xmm& dest, Xmm src1, Xmm src2) {
+          const TypeName part_type =
+              static_cast<TypeName>(i.instr->flags & 0xFF);
+          const uint32_t arithmetic_flags = i.instr->flags >> 8;
+          bool is_unsigned = !!(arithmetic_flags & ARITHMETIC_UNSIGNED);
+          bool saturate = !!(arithmetic_flags & ARITHMETIC_SATURATE);
+          switch (part_type) {
+            case INT8_TYPE:
+              if (saturate) {
+                // TODO(benvanik): trace DID_SATURATE
+                if (is_unsigned) {
+                  e.vpsubusb(dest, src1, src2);
+                } else {
+                  e.vpsubsb(dest, src1, src2);
+                }
+              } else {
+                e.vpsubb(dest, src1, src2);
+              }
+              break;
+            case INT16_TYPE:
+              if (saturate) {
+                // TODO(benvanik): trace DID_SATURATE
+                if (is_unsigned) {
+                  e.vpsubusw(dest, src1, src2);
+                } else {
+                  e.vpsubsw(dest, src1, src2);
+                }
+              } else {
+                e.vpsubw(dest, src1, src2);
+              }
+              break;
+            case INT32_TYPE:
+              if (saturate) {
+                if (is_unsigned) {
+                  // xmm0 is the only temp register that can be used by
+                  // src1/src2.
+                  e.vpsubd(e.xmm1, src1, src2);
+
+                  // If result is greater than either of the inputs, we've
+                  // underflowed (only need to check one input)
+                  // if (res > src1) then underflowed
+                  // http://locklessinc.com/articles/sat_arithmetic/
+                  e.vpxor(e.xmm2, src1, e.GetXmmConstPtr(XMMSignMaskI32));
+                  e.vpxor(e.xmm0, e.xmm1, e.GetXmmConstPtr(XMMSignMaskI32));
+                  e.vpcmpgtd(e.xmm0, e.xmm0, e.xmm2);
+                  e.vpandn(dest, e.xmm0, e.xmm1);
+                } else {
+                  e.vpsubd(e.xmm1, src1, src2);
+
+                  // We can only overflow if the signs of the operands are
+                  // opposite. If signs are opposite and result sign isn't the
+                  // same as src1's sign, we've overflowed. if ((s32b)((src1 ^
+                  // src2) & (src1 ^ res)) < 0) then overflowed
+                  // http://locklessinc.com/articles/sat_arithmetic/
+                  e.vpxor(e.xmm2, src1, src2);
+                  e.vpxor(e.xmm3, src1, e.xmm1);
+                  e.vpand(e.xmm2, e.xmm2, e.xmm3);
+
+                  // Set any negative overflowed elements of src1 to INT_MIN
+                  e.vpand(e.xmm3, src1, e.xmm2);
+                  e.vblendvps(e.xmm1, e.xmm1, e.GetXmmConstPtr(XMMSignMaskI32),
+                              e.xmm3);
+
+                  // Set any positive overflowed elements of src1 to INT_MAX
+                  e.vpandn(e.xmm3, src1, e.xmm2);
+                  e.vblendvps(dest, e.xmm1, e.GetXmmConstPtr(XMMAbsMaskPS),
+                              e.xmm3);
+                }
+              } else {
+                e.vpsubd(dest, src1, src2);
+              }
+              break;
+            case FLOAT32_TYPE:
+              e.vsubps(dest, src1, src2);
+              break;
+            default:
+              assert_unhandled_case(part_type);
+              break;
+          }
+        });
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_SUB, VECTOR_SUB);
+
+// ============================================================================
+// OPCODE_VECTOR_SHL
+// ============================================================================
+template <typename T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
+static __m128i EmulateVectorShl(void*, __m128i src1, __m128i src2) {
+  alignas(16) T value[16 / sizeof(T)];
+  alignas(16) T shamt[16 / sizeof(T)];
+
+  // Load SSE registers into a C array.
+  _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
+  _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
+
+  for (size_t i = 0; i < (16 / sizeof(T)); ++i) {
+    value[i] = value[i] << (shamt[i] & ((sizeof(T) * 8) - 1));
+  }
+
+  // Store result and return it.
+  return _mm_load_si128(reinterpret_cast<__m128i*>(value));
+}
+
+struct VECTOR_SHL_V128
+    : Sequence<VECTOR_SHL_V128, I<OPCODE_VECTOR_SHL, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    switch (i.instr->flags) {
+      case INT8_TYPE:
+        EmitInt8(e, i);
+        break;
+      case INT16_TYPE:
+        EmitInt16(e, i);
+        break;
+      case INT32_TYPE:
+        EmitInt32(e, i);
+        break;
+      default:
+        assert_always();
+        break;
+    }
+  }
+
+  static void EmitInt8(X64Emitter& e, const EmitArgType& i) {
+    // TODO(benvanik): native version (with shift magic).
+    if (i.src2.is_constant) {
+      e.LoadConstantXmm(e.xmm0, i.src2.constant());
+      e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+    } else {
+      e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+    }
+    e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
+    e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShl<uint8_t>));
+    e.vmovaps(i.dest, e.xmm0);
+  }
+
+  static void EmitInt16(X64Emitter& e, const EmitArgType& i) {
+    Xmm src1;
+    if (i.src1.is_constant) {
+      src1 = e.xmm2;
+      e.LoadConstantXmm(src1, i.src1.constant());
+    } else {
+      src1 = i.src1;
+    }
+
+    if (i.src2.is_constant) {
+      const auto& shamt = i.src2.constant();
+      bool all_same = true;
+      for (size_t n = 0; n < 8 - n; ++n) {
+        if (shamt.u16[n] != shamt.u16[n + 1]) {
+          all_same = false;
+          break;
+        }
+      }
+      if (all_same) {
+        // Every count is the same, so we can use vpsllw.
+        e.vpsllw(i.dest, src1, shamt.u16[0] & 0xF);
+        return;
+      }
+    }
+
+    // Shift 8 words in src1 by amount specified in src2.
+    Xbyak::Label emu, end;
+
+    // Only bother with this check if shift amt isn't constant.
+    if (!i.src2.is_constant) {
+      // See if the shift is equal first for a shortcut.
+      e.vpshuflw(e.xmm0, i.src2, 0b00000000);
+      e.vpshufd(e.xmm0, e.xmm0, 0b00000000);
+      e.vpxor(e.xmm1, e.xmm0, i.src2);
+      e.vptest(e.xmm1, e.xmm1);
+      e.jnz(emu);
+
+      // Equal. Shift using vpsllw.
+      e.mov(e.rax, 0xF);
+      e.vmovq(e.xmm1, e.rax);
+      e.vpand(e.xmm0, e.xmm0, e.xmm1);
+      e.vpsllw(i.dest, src1, e.xmm0);
+      e.jmp(end);
+    }
+
+    // TODO(benvanik): native version (with shift magic).
+    e.L(emu);
+    if (i.src2.is_constant) {
+      e.LoadConstantXmm(e.xmm0, i.src2.constant());
+      e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+    } else {
+      e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+    }
+    e.lea(e.GetNativeParam(0), e.StashXmm(0, src1));
+    e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShl<uint16_t>));
+    e.vmovaps(i.dest, e.xmm0);
+
+    e.L(end);
+  }
+
+  static void EmitInt32(X64Emitter& e, const EmitArgType& i) {
+    Xmm src1;
+    if (i.src1.is_constant) {
+      src1 = e.xmm2;
+      e.LoadConstantXmm(src1, i.src1.constant());
+    } else {
+      src1 = i.src1;
+    }
+
+    if (i.src2.is_constant) {
+      const auto& shamt = i.src2.constant();
+      bool all_same = true;
+      for (size_t n = 0; n < 4 - n; ++n) {
+        if (shamt.u32[n] != shamt.u32[n + 1]) {
+          all_same = false;
+          break;
+        }
+      }
+      if (all_same) {
+        // Every count is the same, so we can use vpslld.
+        e.vpslld(i.dest, src1, shamt.u8[0] & 0x1F);
+        return;
+      }
+    }
+
+    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
+      if (i.src2.is_constant) {
+        const auto& shamt = i.src2.constant();
+        // Counts differ, so pre-mask and load constant.
+        vec128_t masked = i.src2.constant();
+        for (size_t n = 0; n < 4; ++n) {
+          masked.u32[n] &= 0x1F;
+        }
+        e.LoadConstantXmm(e.xmm0, masked);
+        e.vpsllvd(i.dest, src1, e.xmm0);
+      } else {
+        // Fully variable shift.
+        // src shift mask may have values >31, and x86 sets to zero when
+        // that happens so we mask.
+        e.vandps(e.xmm0, i.src2, e.GetXmmConstPtr(XMMShiftMaskPS));
+        e.vpsllvd(i.dest, src1, e.xmm0);
+      }
+    } else {
+      // Shift 4 words in src1 by amount specified in src2.
+      Xbyak::Label emu, end;
+
+      // See if the shift is equal first for a shortcut.
+      // Only bother with this check if shift amt isn't constant.
+      if (!i.src2.is_constant) {
+        e.vpshufd(e.xmm0, i.src2, 0b00000000);
+        e.vpxor(e.xmm1, e.xmm0, i.src2);
+        e.vptest(e.xmm1, e.xmm1);
+        e.jnz(emu);
+
+        // Equal. Shift using vpsrad.
+        e.mov(e.rax, 0x1F);
+        e.vmovq(e.xmm1, e.rax);
+        e.vpand(e.xmm0, e.xmm0, e.xmm1);
+        e.vpslld(i.dest, src1, e.xmm0);
+        e.jmp(end);
+      }
+
+      // TODO(benvanik): native version (with shift magic).
+      e.L(emu);
+      if (i.src2.is_constant) {
+        e.LoadConstantXmm(e.xmm0, i.src2.constant());
+        e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+      } else {
+        e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+      }
+      e.lea(e.GetNativeParam(0), e.StashXmm(0, src1));
+      e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShl<uint32_t>));
+      e.vmovaps(i.dest, e.xmm0);
+
+      e.L(end);
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_SHL, VECTOR_SHL_V128);
+
+// ============================================================================
+// OPCODE_VECTOR_SHR
+// ============================================================================
+template <typename T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
+static __m128i EmulateVectorShr(void*, __m128i src1, __m128i src2) {
+  alignas(16) T value[16 / sizeof(T)];
+  alignas(16) T shamt[16 / sizeof(T)];
+
+  // Load SSE registers into a C array.
+  _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
+  _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
+
+  for (size_t i = 0; i < (16 / sizeof(T)); ++i) {
+    value[i] = value[i] >> (shamt[i] & ((sizeof(T) * 8) - 1));
+  }
+
+  // Store result and return it.
+  return _mm_load_si128(reinterpret_cast<__m128i*>(value));
+}
+
+struct VECTOR_SHR_V128
+    : Sequence<VECTOR_SHR_V128, I<OPCODE_VECTOR_SHR, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    switch (i.instr->flags) {
+      case INT8_TYPE:
+        EmitInt8(e, i);
+        break;
+      case INT16_TYPE:
+        EmitInt16(e, i);
+        break;
+      case INT32_TYPE:
+        EmitInt32(e, i);
+        break;
+      default:
+        assert_always();
+        break;
+    }
+  }
+
+  static void EmitInt8(X64Emitter& e, const EmitArgType& i) {
+    // TODO(benvanik): native version (with shift magic).
+    if (i.src2.is_constant) {
+      e.LoadConstantXmm(e.xmm0, i.src2.constant());
+      e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+    } else {
+      e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+    }
+    e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
+    e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShr<uint8_t>));
+    e.vmovaps(i.dest, e.xmm0);
+  }
+
+  static void EmitInt16(X64Emitter& e, const EmitArgType& i) {
+    if (i.src2.is_constant) {
+      const auto& shamt = i.src2.constant();
+      bool all_same = true;
+      for (size_t n = 0; n < 8 - n; ++n) {
+        if (shamt.u16[n] != shamt.u16[n + 1]) {
+          all_same = false;
+          break;
+        }
+      }
+      if (all_same) {
+        // Every count is the same, so we can use vpsllw.
+        e.vpsrlw(i.dest, i.src1, shamt.u16[0] & 0xF);
+        return;
+      }
+    }
+
+    // Shift 8 words in src1 by amount specified in src2.
+    Xbyak::Label emu, end;
+
+    // See if the shift is equal first for a shortcut.
+    // Only bother with this check if shift amt isn't constant.
+    if (!i.src2.is_constant) {
+      e.vpshuflw(e.xmm0, i.src2, 0b00000000);
+      e.vpshufd(e.xmm0, e.xmm0, 0b00000000);
+      e.vpxor(e.xmm1, e.xmm0, i.src2);
+      e.vptest(e.xmm1, e.xmm1);
+      e.jnz(emu);
+
+      // Equal. Shift using vpsrlw.
+      e.mov(e.rax, 0xF);
+      e.vmovq(e.xmm1, e.rax);
+      e.vpand(e.xmm0, e.xmm0, e.xmm1);
+      e.vpsrlw(i.dest, i.src1, e.xmm0);
+      e.jmp(end);
+    }
+
+    // TODO(benvanik): native version (with shift magic).
+    e.L(emu);
+    if (i.src2.is_constant) {
+      e.LoadConstantXmm(e.xmm0, i.src2.constant());
+      e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+    } else {
+      e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+    }
+    e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
+    e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShr<uint16_t>));
+    e.vmovaps(i.dest, e.xmm0);
+
+    e.L(end);
+  }
+
+  static void EmitInt32(X64Emitter& e, const EmitArgType& i) {
+    Xmm src1;
+    if (i.src1.is_constant) {
+      src1 = e.xmm2;
+      e.LoadConstantXmm(src1, i.src1.constant());
+    } else {
+      src1 = i.src1;
+    }
+
+    if (i.src2.is_constant) {
+      const auto& shamt = i.src2.constant();
+      bool all_same = true;
+      for (size_t n = 0; n < 4 - n; ++n) {
+        if (shamt.u32[n] != shamt.u32[n + 1]) {
+          all_same = false;
+          break;
+        }
+      }
+      if (all_same) {
+        // Every count is the same, so we can use vpsrld.
+        e.vpsrld(i.dest, src1, shamt.u8[0] & 0x1F);
+        return;
+      } else {
+        if (e.IsFeatureEnabled(kX64EmitAVX2)) {
+          // Counts differ, so pre-mask and load constant.
+          vec128_t masked = i.src2.constant();
+          for (size_t n = 0; n < 4; ++n) {
+            masked.u32[n] &= 0x1F;
+          }
+          e.LoadConstantXmm(e.xmm0, masked);
+          e.vpsrlvd(i.dest, src1, e.xmm0);
+          return;
+        }
+      }
+    }
+
+    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
+      // Fully variable shift.
+      // src shift mask may have values >31, and x86 sets to zero when
+      // that happens so we mask.
+      e.vandps(e.xmm0, i.src2, e.GetXmmConstPtr(XMMShiftMaskPS));
+      e.vpsrlvd(i.dest, src1, e.xmm0);
+    } else {
+      // Shift 4 words in src1 by amount specified in src2.
+      Xbyak::Label emu, end;
+
+      // See if the shift is equal first for a shortcut.
+      // Only bother with this check if shift amt isn't constant.
+      if (!i.src2.is_constant) {
+        e.vpshufd(e.xmm0, i.src2, 0b00000000);
+        e.vpxor(e.xmm1, e.xmm0, i.src2);
+        e.vptest(e.xmm1, e.xmm1);
+        e.jnz(emu);
+
+        // Equal. Shift using vpsrld.
+        e.mov(e.rax, 0x1F);
+        e.vmovq(e.xmm1, e.rax);
+        e.vpand(e.xmm0, e.xmm0, e.xmm1);
+        e.vpsrld(i.dest, src1, e.xmm0);
+        e.jmp(end);
+      }
+
+      // TODO(benvanik): native version.
+      e.L(emu);
+      if (i.src2.is_constant) {
+        e.LoadConstantXmm(e.xmm0, i.src2.constant());
+        e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+      } else {
+        e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+      }
+      e.lea(e.GetNativeParam(0), e.StashXmm(0, src1));
+      e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShr<uint32_t>));
+      e.vmovaps(i.dest, e.xmm0);
+
+      e.L(end);
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_SHR, VECTOR_SHR_V128);
+
+// ============================================================================
+// OPCODE_VECTOR_SHA
+// ============================================================================
+struct VECTOR_SHA_V128
+    : Sequence<VECTOR_SHA_V128, I<OPCODE_VECTOR_SHA, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    switch (i.instr->flags) {
+      case INT8_TYPE:
+        EmitInt8(e, i);
+        break;
+      case INT16_TYPE:
+        EmitInt16(e, i);
+        break;
+      case INT32_TYPE:
+        EmitInt32(e, i);
+        break;
+      default:
+        assert_always();
+        break;
+    }
+  }
+
+  static void EmitInt8(X64Emitter& e, const EmitArgType& i) {
+    // TODO(benvanik): native version (with shift magic).
+    if (i.src2.is_constant) {
+      e.LoadConstantXmm(e.xmm0, i.src2.constant());
+      e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+    } else {
+      e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+    }
+    e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
+    e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShr<int8_t>));
+    e.vmovaps(i.dest, e.xmm0);
+  }
+
+  static void EmitInt16(X64Emitter& e, const EmitArgType& i) {
+    if (i.src2.is_constant) {
+      const auto& shamt = i.src2.constant();
+      bool all_same = true;
+      for (size_t n = 0; n < 8 - n; ++n) {
+        if (shamt.u16[n] != shamt.u16[n + 1]) {
+          all_same = false;
+          break;
+        }
+      }
+      if (all_same) {
+        // Every count is the same, so we can use vpsraw.
+        e.vpsraw(i.dest, i.src1, shamt.u16[0] & 0xF);
+        return;
+      }
+    }
+
+    // Shift 8 words in src1 by amount specified in src2.
+    Xbyak::Label emu, end;
+
+    // See if the shift is equal first for a shortcut.
+    // Only bother with this check if shift amt isn't constant.
+    if (!i.src2.is_constant) {
+      e.vpshuflw(e.xmm0, i.src2, 0b00000000);
+      e.vpshufd(e.xmm0, e.xmm0, 0b00000000);
+      e.vpxor(e.xmm1, e.xmm0, i.src2);
+      e.vptest(e.xmm1, e.xmm1);
+      e.jnz(emu);
+
+      // Equal. Shift using vpsraw.
+      e.mov(e.rax, 0xF);
+      e.vmovq(e.xmm1, e.rax);
+      e.vpand(e.xmm0, e.xmm0, e.xmm1);
+      e.vpsraw(i.dest, i.src1, e.xmm0);
+      e.jmp(end);
+    }
+
+    // TODO(benvanik): native version (with shift magic).
+    e.L(emu);
+    if (i.src2.is_constant) {
+      e.LoadConstantXmm(e.xmm0, i.src2.constant());
+      e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+    } else {
+      e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+    }
+    e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
+    e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShr<int16_t>));
+    e.vmovaps(i.dest, e.xmm0);
+
+    e.L(end);
+  }
+
+  static void EmitInt32(X64Emitter& e, const EmitArgType& i) {
+    if (i.src2.is_constant) {
+      const auto& shamt = i.src2.constant();
+      bool all_same = true;
+      for (size_t n = 0; n < 4 - n; ++n) {
+        if (shamt.u32[n] != shamt.u32[n + 1]) {
+          all_same = false;
+          break;
+        }
+      }
+      if (all_same) {
+        // Every count is the same, so we can use vpsrad.
+        e.vpsrad(i.dest, i.src1, shamt.u32[0] & 0x1F);
+        return;
+      }
+    }
+
+    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
+      // src shift mask may have values >31, and x86 sets to zero when
+      // that happens so we mask.
+      if (i.src2.is_constant) {
+        e.LoadConstantXmm(e.xmm0, i.src2.constant());
+        e.vandps(e.xmm0, e.GetXmmConstPtr(XMMShiftMaskPS));
+      } else {
+        e.vandps(e.xmm0, i.src2, e.GetXmmConstPtr(XMMShiftMaskPS));
+      }
+      e.vpsravd(i.dest, i.src1, e.xmm0);
+    } else {
+      // Shift 4 words in src1 by amount specified in src2.
+      Xbyak::Label emu, end;
+
+      // See if the shift is equal first for a shortcut.
+      // Only bother with this check if shift amt isn't constant.
+      if (!i.src2.is_constant) {
+        e.vpshufd(e.xmm0, i.src2, 0b00000000);
+        e.vpxor(e.xmm1, e.xmm0, i.src2);
+        e.vptest(e.xmm1, e.xmm1);
+        e.jnz(emu);
+
+        // Equal. Shift using vpsrad.
+        e.mov(e.rax, 0x1F);
+        e.vmovq(e.xmm1, e.rax);
+        e.vpand(e.xmm0, e.xmm0, e.xmm1);
+        e.vpsrad(i.dest, i.src1, e.xmm0);
+        e.jmp(end);
+      }
+
+      // TODO(benvanik): native version.
+      e.L(emu);
+      if (i.src2.is_constant) {
+        e.LoadConstantXmm(e.xmm0, i.src2.constant());
+        e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+      } else {
+        e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+      }
+      e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
+      e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShr<int32_t>));
+      e.vmovaps(i.dest, e.xmm0);
+
+      e.L(end);
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_SHA, VECTOR_SHA_V128);
+
+// ============================================================================
+// OPCODE_VECTOR_ROTATE_LEFT
+// ============================================================================
+template <typename T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
+static __m128i EmulateVectorRotateLeft(void*, __m128i src1, __m128i src2) {
+  alignas(16) T value[16 / sizeof(T)];
+  alignas(16) T shamt[16 / sizeof(T)];
+
+  // Load SSE registers into a C array.
+  _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
+  _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
+
+  for (size_t i = 0; i < (16 / sizeof(T)); ++i) {
+    value[i] = xe::rotate_left<T>(value[i], shamt[i] & ((sizeof(T) * 8) - 1));
+  }
+
+  // Store result and return it.
+  return _mm_load_si128(reinterpret_cast<__m128i*>(value));
+}
+
+// TODO(benvanik): AVX512 has a native variable rotate (rolv).
+struct VECTOR_ROTATE_LEFT_V128
+    : Sequence<VECTOR_ROTATE_LEFT_V128,
+               I<OPCODE_VECTOR_ROTATE_LEFT, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    switch (i.instr->flags) {
+      case INT8_TYPE:
+        // TODO(benvanik): native version (with shift magic).
+        e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
+        if (i.src2.is_constant) {
+          e.LoadConstantXmm(e.xmm0, i.src2.constant());
+          e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+        } else {
+          e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+        }
+        e.CallNativeSafe(
+            reinterpret_cast<void*>(EmulateVectorRotateLeft<uint8_t>));
+        e.vmovaps(i.dest, e.xmm0);
+        break;
+      case INT16_TYPE:
+        // TODO(benvanik): native version (with shift magic).
+        e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
+        if (i.src2.is_constant) {
+          e.LoadConstantXmm(e.xmm0, i.src2.constant());
+          e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+        } else {
+          e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+        }
+        e.CallNativeSafe(
+            reinterpret_cast<void*>(EmulateVectorRotateLeft<uint16_t>));
+        e.vmovaps(i.dest, e.xmm0);
+        break;
+      case INT32_TYPE: {
+        if (e.IsFeatureEnabled(kX64EmitAVX2)) {
+          Xmm temp = i.dest;
+          if (i.dest == i.src1 || i.dest == i.src2) {
+            temp = e.xmm2;
+          }
+          // Shift left (to get high bits):
+          e.vpand(e.xmm0, i.src2, e.GetXmmConstPtr(XMMShiftMaskPS));
+          e.vpsllvd(e.xmm1, i.src1, e.xmm0);
+          // Shift right (to get low bits):
+          e.vmovaps(temp, e.GetXmmConstPtr(XMMPI32));
+          e.vpsubd(temp, e.xmm0);
+          e.vpsrlvd(i.dest, i.src1, temp);
+          // Merge:
+          e.vpor(i.dest, e.xmm1);
+        } else {
+          // TODO(benvanik): non-AVX2 native version.
+          e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
+          if (i.src2.is_constant) {
+            e.LoadConstantXmm(e.xmm0, i.src2.constant());
+            e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+          } else {
+            e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+          }
+          e.CallNativeSafe(
+              reinterpret_cast<void*>(EmulateVectorRotateLeft<uint32_t>));
+          e.vmovaps(i.dest, e.xmm0);
+        }
+        break;
+      }
+      default:
+        assert_always();
+        break;
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_ROTATE_LEFT, VECTOR_ROTATE_LEFT_V128);
+
+// ============================================================================
+// OPCODE_VECTOR_AVERAGE
+// ============================================================================
+template <typename T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
+static __m128i EmulateVectorAverage(void*, __m128i src1, __m128i src2) {
+  alignas(16) T src1v[16 / sizeof(T)];
+  alignas(16) T src2v[16 / sizeof(T)];
+  alignas(16) T value[16 / sizeof(T)];
+
+  // Load SSE registers into a C array.
+  _mm_store_si128(reinterpret_cast<__m128i*>(src1v), src1);
+  _mm_store_si128(reinterpret_cast<__m128i*>(src2v), src2);
+
+  for (size_t i = 0; i < (16 / sizeof(T)); ++i) {
+    auto t = (uint64_t(src1v[i]) + uint64_t(src2v[i]) + 1) / 2;
+    value[i] = T(t);
+  }
+
+  // Store result and return it.
+  return _mm_load_si128(reinterpret_cast<__m128i*>(value));
+}
+
+struct VECTOR_AVERAGE
+    : Sequence<VECTOR_AVERAGE,
+               I<OPCODE_VECTOR_AVERAGE, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    EmitCommutativeBinaryXmmOp(
+        e, i,
+        [&i](X64Emitter& e, const Xmm& dest, const Xmm& src1, const Xmm& src2) {
+          const TypeName part_type =
+              static_cast<TypeName>(i.instr->flags & 0xFF);
+          const uint32_t arithmetic_flags = i.instr->flags >> 8;
+          bool is_unsigned = !!(arithmetic_flags & ARITHMETIC_UNSIGNED);
+          switch (part_type) {
+            case INT8_TYPE:
+              if (is_unsigned) {
+                e.vpavgb(dest, src1, src2);
+              } else {
+                assert_always();
+              }
+              break;
+            case INT16_TYPE:
+              if (is_unsigned) {
+                e.vpavgw(dest, src1, src2);
+              } else {
+                assert_always();
+              }
+              break;
+            case INT32_TYPE:
+              // No 32bit averages in AVX.
+              if (is_unsigned) {
+                if (i.src2.is_constant) {
+                  e.LoadConstantXmm(e.xmm0, i.src2.constant());
+                  e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+                } else {
+                  e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+                }
+                e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
+                e.CallNativeSafe(
+                    reinterpret_cast<void*>(EmulateVectorAverage<uint32_t>));
+                e.vmovaps(i.dest, e.xmm0);
+              } else {
+                if (i.src2.is_constant) {
+                  e.LoadConstantXmm(e.xmm0, i.src2.constant());
+                  e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+                } else {
+                  e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+                }
+                e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
+                e.CallNativeSafe(
+                    reinterpret_cast<void*>(EmulateVectorAverage<int32_t>));
+                e.vmovaps(i.dest, e.xmm0);
+              }
+              break;
+            default:
+              assert_unhandled_case(part_type);
+              break;
+          }
+        });
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_VECTOR_AVERAGE, VECTOR_AVERAGE);
+
+// ============================================================================
+// OPCODE_INSERT
+// ============================================================================
+struct INSERT_I8
+    : Sequence<INSERT_I8, I<OPCODE_INSERT, V128Op, V128Op, I8Op, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.is_constant);
+    e.vpinsrb(i.dest, i.src3.reg().cvt32(), i.src2.constant() ^ 0x3);
+  }
+};
+struct INSERT_I16
+    : Sequence<INSERT_I16, I<OPCODE_INSERT, V128Op, V128Op, I8Op, I16Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.is_constant);
+    e.vpinsrw(i.dest, i.src3.reg().cvt32(), i.src2.constant() ^ 0x1);
+  }
+};
+struct INSERT_I32
+    : Sequence<INSERT_I32, I<OPCODE_INSERT, V128Op, V128Op, I8Op, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.is_constant);
+    e.vpinsrd(i.dest, i.src3, i.src2.constant());
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_INSERT, INSERT_I8, INSERT_I16, INSERT_I32);
+
+// ============================================================================
+// OPCODE_EXTRACT
+// ============================================================================
+// TODO(benvanik): sequence extract/splat:
+//  v0.i32 = extract v0.v128, 0
+//  v0.v128 = splat v0.i32
+// This can be a single broadcast.
+struct EXTRACT_I8
+    : Sequence<EXTRACT_I8, I<OPCODE_EXTRACT, I8Op, V128Op, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    if (i.src2.is_constant) {
+      e.vpextrb(i.dest.reg().cvt32(), i.src1, VEC128_B(i.src2.constant()));
+    } else {
+      e.mov(e.eax, 0x00000003);
+      e.xor_(e.al, i.src2);
+      e.and_(e.al, 0x1F);
+      e.vmovd(e.xmm0, e.eax);
+      e.vpshufb(e.xmm0, i.src1, e.xmm0);
+      e.vmovd(i.dest.reg().cvt32(), e.xmm0);
+      e.and_(i.dest, uint8_t(0xFF));
+    }
+  }
+};
+struct EXTRACT_I16
+    : Sequence<EXTRACT_I16, I<OPCODE_EXTRACT, I16Op, V128Op, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    if (i.src2.is_constant) {
+      e.vpextrw(i.dest.reg().cvt32(), i.src1, VEC128_W(i.src2.constant()));
+    } else {
+      e.mov(e.al, i.src2);
+      e.xor_(e.al, 0x01);
+      e.shl(e.al, 1);
+      e.mov(e.ah, e.al);
+      e.add(e.ah, 1);
+      e.vmovd(e.xmm0, e.eax);
+      e.vpshufb(e.xmm0, i.src1, e.xmm0);
+      e.vmovd(i.dest.reg().cvt32(), e.xmm0);
+      e.and_(i.dest.reg().cvt32(), 0xFFFFu);
+    }
+  }
+};
+struct EXTRACT_I32
+    : Sequence<EXTRACT_I32, I<OPCODE_EXTRACT, I32Op, V128Op, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    static const vec128_t extract_table_32[4] = {
+        vec128b(3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
+        vec128b(7, 6, 5, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
+        vec128b(11, 10, 9, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
+        vec128b(15, 14, 13, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
+    };
+    if (i.src2.is_constant) {
+      // TODO(gibbed): add support to constant propagation pass for
+      // OPCODE_EXTRACT.
+      Xmm src1;
+      if (i.src1.is_constant) {
+        src1 = e.xmm0;
+        e.LoadConstantXmm(src1, i.src1.constant());
+      } else {
+        src1 = i.src1;
+      }
+      if (i.src2.constant() == 0) {
+        e.vmovd(i.dest, src1);
+      } else {
+        e.vpextrd(i.dest, src1, VEC128_D(i.src2.constant()));
+      }
+    } else {
+      // TODO(benvanik): try out hlide's version:
+      // e.mov(e.eax, 3);
+      // e.and_(e.al, i.src2);       // eax = [(i&3), 0, 0, 0]
+      // e.imul(e.eax, 0x04040404); // [(i&3)*4, (i&3)*4, (i&3)*4, (i&3)*4]
+      // e.add(e.eax, 0x00010203);  // [((i&3)*4)+3, ((i&3)*4)+2, ((i&3)*4)+1,
+      // ((i&3)*4)+0]
+      // e.vmovd(e.xmm0, e.eax);
+      // e.vpshufb(e.xmm0, i.src1, e.xmm0);
+      // e.vmovd(i.dest.reg().cvt32(), e.xmm0);
+      // Get the desired word in xmm0, then extract that.
+      Xmm src1;
+      if (i.src1.is_constant) {
+        src1 = e.xmm1;
+        e.LoadConstantXmm(src1, i.src1.constant());
+      } else {
+        src1 = i.src1.reg();
+      }
+
+      e.xor_(e.rax, e.rax);
+      e.mov(e.al, i.src2);
+      e.and_(e.al, 0x03);
+      e.shl(e.al, 4);
+      e.mov(e.rdx, reinterpret_cast<uint64_t>(extract_table_32));
+      e.vmovaps(e.xmm0, e.ptr[e.rdx + e.rax]);
+      e.vpshufb(e.xmm0, src1, e.xmm0);
+      e.vpextrd(i.dest, e.xmm0, 0);
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_EXTRACT, EXTRACT_I8, EXTRACT_I16, EXTRACT_I32);
+
+// ============================================================================
+// OPCODE_SPLAT
+// ============================================================================
+// Copy a value into all elements of a vector
+struct SPLAT_I8 : Sequence<SPLAT_I8, I<OPCODE_SPLAT, V128Op, I8Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    if (i.src1.is_constant) {
+      // TODO(benvanik): faster constant splats.
+      e.mov(e.eax, i.src1.constant());
+      e.vmovd(e.xmm0, e.eax);
+    } else {
+      e.vmovd(e.xmm0, i.src1.reg().cvt32());
+    }
+
+    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
+      e.vpbroadcastb(i.dest, e.xmm0);
+    } else {
+      e.vpunpcklbw(e.xmm0, e.xmm0);
+      e.vpunpcklwd(e.xmm0, e.xmm0);
+      e.vpshufd(i.dest, e.xmm0, 0);
+    }
+  }
+};
+struct SPLAT_I16 : Sequence<SPLAT_I16, I<OPCODE_SPLAT, V128Op, I16Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    if (i.src1.is_constant) {
+      // TODO(benvanik): faster constant splats.
+      e.mov(e.eax, i.src1.constant());
+      e.vmovd(e.xmm0, e.eax);
+    } else {
+      e.vmovd(e.xmm0, i.src1.reg().cvt32());
+    }
+
+    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
+      e.vpbroadcastw(i.dest, e.xmm0);
+    } else {
+      e.vpunpcklwd(e.xmm0, e.xmm0);  // unpack low word data
+      e.vpshufd(i.dest, e.xmm0, 0);
+    }
+  }
+};
+struct SPLAT_I32 : Sequence<SPLAT_I32, I<OPCODE_SPLAT, V128Op, I32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    if (i.src1.is_constant) {
+      // TODO(benvanik): faster constant splats.
+      e.mov(e.eax, i.src1.constant());
+      e.vmovd(e.xmm0, e.eax);
+    } else {
+      e.vmovd(e.xmm0, i.src1);
+    }
+
+    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
+      e.vpbroadcastd(i.dest, e.xmm0);
+    } else {
+      e.vpshufd(i.dest, e.xmm0, 0);
+    }
+  }
+};
+struct SPLAT_F32 : Sequence<SPLAT_F32, I<OPCODE_SPLAT, V128Op, F32Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
+      if (i.src1.is_constant) {
+        // TODO(benvanik): faster constant splats.
+        e.mov(e.eax, i.src1.value->constant.i32);
+        e.vmovd(e.xmm0, e.eax);
+        e.vbroadcastss(i.dest, e.xmm0);
+      } else {
+        e.vbroadcastss(i.dest, i.src1);
+      }
+    } else {
+      if (i.src1.is_constant) {
+        e.mov(e.eax, i.src1.value->constant.i32);
+        e.vmovd(i.dest, e.eax);
+        e.vshufps(i.dest, i.dest, i.dest, 0);
+      } else {
+        e.vshufps(i.dest, i.src1, i.src1, 0);
+      }
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_SPLAT, SPLAT_I8, SPLAT_I16, SPLAT_I32, SPLAT_F32);
+
+// ============================================================================
+// OPCODE_PERMUTE
+// ============================================================================
+struct PERMUTE_I32
+    : Sequence<PERMUTE_I32, I<OPCODE_PERMUTE, V128Op, I32Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.instr->flags == INT32_TYPE);
+    // Permute words between src2 and src3.
+    // TODO(benvanik): check src3 for zero. if 0, we can use pshufb.
+    if (i.src1.is_constant) {
+      uint32_t control = i.src1.constant();
+      // Shuffle things into the right places in dest & xmm0,
+      // then we blend them together.
+      uint32_t src_control =
+          (((control >> 24) & 0x3) << 6) | (((control >> 16) & 0x3) << 4) |
+          (((control >> 8) & 0x3) << 2) | (((control >> 0) & 0x3) << 0);
+
+      uint32_t blend_control = 0;
+      if (e.IsFeatureEnabled(kX64EmitAVX2)) {
+        // Blender for vpblendd
+        blend_control =
+            (((control >> 26) & 0x1) << 3) | (((control >> 18) & 0x1) << 2) |
+            (((control >> 10) & 0x1) << 1) | (((control >> 2) & 0x1) << 0);
+      } else {
+        // Blender for vpblendw
+        blend_control =
+            (((control >> 26) & 0x1) << 6) | (((control >> 18) & 0x1) << 4) |
+            (((control >> 10) & 0x1) << 2) | (((control >> 2) & 0x1) << 0);
+        blend_control |= blend_control << 1;
+      }
+
+      // TODO(benvanik): if src2/src3 are constants, shuffle now!
+      Xmm src2;
+      if (i.src2.is_constant) {
+        src2 = e.xmm1;
+        e.LoadConstantXmm(src2, i.src2.constant());
+      } else {
+        src2 = i.src2;
+      }
+      Xmm src3;
+      if (i.src3.is_constant) {
+        src3 = e.xmm2;
+        e.LoadConstantXmm(src3, i.src3.constant());
+      } else {
+        src3 = i.src3;
+      }
+      if (i.dest != src3) {
+        e.vpshufd(i.dest, src2, src_control);
+        e.vpshufd(e.xmm0, src3, src_control);
+      } else {
+        e.vmovaps(e.xmm0, src3);
+        e.vpshufd(i.dest, src2, src_control);
+        e.vpshufd(e.xmm0, e.xmm0, src_control);
+      }
+
+      if (e.IsFeatureEnabled(kX64EmitAVX2)) {
+        e.vpblendd(i.dest, e.xmm0, blend_control);  // $0 = $1 <blend> $2
+      } else {
+        e.vpblendw(i.dest, e.xmm0, blend_control);  // $0 = $1 <blend> $2
+      }
+    } else {
+      // Permute by non-constant.
+      assert_always();
+    }
+  }
+};
+struct PERMUTE_V128
+    : Sequence<PERMUTE_V128,
+               I<OPCODE_PERMUTE, V128Op, V128Op, V128Op, V128Op>> {
+  static void EmitByInt8(X64Emitter& e, const EmitArgType& i) {
+    // TODO(benvanik): find out how to do this with only one temp register!
+    // Permute bytes between src2 and src3.
+    // src1 is an array of indices corresponding to positions within src2 and
+    // src3.
+    if (i.src3.value->IsConstantZero()) {
+      // Permuting with src2/zero, so just shuffle/mask.
+      if (i.src2.value->IsConstantZero()) {
+        // src2 & src3 are zero, so result will always be zero.
+        e.vpxor(i.dest, i.dest);
+      } else {
+        // Control mask needs to be shuffled.
+        if (i.src1.is_constant) {
+          e.LoadConstantXmm(e.xmm0, i.src1.constant());
+          e.vxorps(e.xmm0, e.xmm0, e.GetXmmConstPtr(XMMSwapWordMask));
+        } else {
+          e.vxorps(e.xmm0, i.src1, e.GetXmmConstPtr(XMMSwapWordMask));
+        }
+        e.vpand(e.xmm0, e.GetXmmConstPtr(XMMPermuteByteMask));
+        if (i.src2.is_constant) {
+          e.LoadConstantXmm(i.dest, i.src2.constant());
+          e.vpshufb(i.dest, i.dest, e.xmm0);
+        } else {
+          e.vpshufb(i.dest, i.src2, e.xmm0);
+        }
+        // Build a mask with values in src2 having 0 and values in src3 having
+        // 1.
+        e.vpcmpgtb(e.xmm0, e.xmm0, e.GetXmmConstPtr(XMMPermuteControl15));
+        e.vpandn(i.dest, e.xmm0, i.dest);
+      }
+    } else {
+      // General permute.
+      // Control mask needs to be shuffled.
+      // TODO(benvanik): do constants here instead of in generated code.
+      if (i.src1.is_constant) {
+        e.LoadConstantXmm(e.xmm2, i.src1.constant());
+        e.vxorps(e.xmm2, e.xmm2, e.GetXmmConstPtr(XMMSwapWordMask));
+      } else {
+        e.vxorps(e.xmm2, i.src1, e.GetXmmConstPtr(XMMSwapWordMask));
+      }
+      e.vpand(e.xmm2, e.GetXmmConstPtr(XMMPermuteByteMask));
+      Xmm src2_shuf = e.xmm0;
+      if (i.src2.value->IsConstantZero()) {
+        e.vpxor(src2_shuf, src2_shuf);
+      } else if (i.src2.is_constant) {
+        e.LoadConstantXmm(src2_shuf, i.src2.constant());
+        e.vpshufb(src2_shuf, src2_shuf, e.xmm2);
+      } else {
+        e.vpshufb(src2_shuf, i.src2, e.xmm2);
+      }
+      Xmm src3_shuf = e.xmm1;
+      if (i.src3.value->IsConstantZero()) {
+        e.vpxor(src3_shuf, src3_shuf);
+      } else if (i.src3.is_constant) {
+        e.LoadConstantXmm(src3_shuf, i.src3.constant());
+        e.vpshufb(src3_shuf, src3_shuf, e.xmm2);
+      } else {
+        e.vpshufb(src3_shuf, i.src3, e.xmm2);
+      }
+      // Build a mask with values in src2 having 0 and values in src3 having 1.
+      e.vpcmpgtb(i.dest, e.xmm2, e.GetXmmConstPtr(XMMPermuteControl15));
+      e.vpblendvb(i.dest, src2_shuf, src3_shuf, i.dest);
+    }
+  }
+
+  static void EmitByInt16(X64Emitter& e, const EmitArgType& i) {
+    // src1 is an array of indices corresponding to positions within src2 and
+    // src3.
+    assert_true(i.src1.is_constant);
+    vec128_t perm = (i.src1.constant() & vec128s(0xF)) ^ vec128s(0x1);
+    vec128_t perm_ctrl = vec128b(0);
+    for (int i = 0; i < 8; i++) {
+      perm_ctrl.i16[i] = perm.i16[i] > 7 ? -1 : 0;
+
+      auto v = uint8_t(perm.u16[i]);
+      perm.u8[i * 2] = v * 2;
+      perm.u8[i * 2 + 1] = v * 2 + 1;
+    }
+    e.LoadConstantXmm(e.xmm0, perm);
+
+    if (i.src2.is_constant) {
+      e.LoadConstantXmm(e.xmm1, i.src2.constant());
+    } else {
+      e.vmovdqa(e.xmm1, i.src2);
+    }
+    if (i.src3.is_constant) {
+      e.LoadConstantXmm(e.xmm2, i.src3.constant());
+    } else {
+      e.vmovdqa(e.xmm2, i.src3);
+    }
+
+    e.vpshufb(e.xmm1, e.xmm1, e.xmm0);
+    e.vpshufb(e.xmm2, e.xmm2, e.xmm0);
+
+    uint8_t mask = 0;
+    for (int i = 0; i < 8; i++) {
+      if (perm_ctrl.i16[i] == 0) {
+        mask |= 1 << (7 - i);
+      }
+    }
+    e.vpblendw(i.dest, e.xmm1, e.xmm2, mask);
+  }
+
+  static void EmitByInt32(X64Emitter& e, const EmitArgType& i) {
+    assert_always();
+  }
+
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    switch (i.instr->flags) {
+      case INT8_TYPE:
+        EmitByInt8(e, i);
+        break;
+      case INT16_TYPE:
+        EmitByInt16(e, i);
+        break;
+      case INT32_TYPE:
+        EmitByInt32(e, i);
+        break;
+      default:
+        assert_unhandled_case(i.instr->flags);
+        return;
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_PERMUTE, PERMUTE_I32, PERMUTE_V128);
+
+// ============================================================================
+// OPCODE_SWIZZLE
+// ============================================================================
+struct SWIZZLE
+    : Sequence<SWIZZLE, I<OPCODE_SWIZZLE, V128Op, V128Op, OffsetOp>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    auto element_type = i.instr->flags;
+    if (element_type == INT8_TYPE) {
+      assert_always();
+    } else if (element_type == INT16_TYPE) {
+      assert_always();
+    } else if (element_type == INT32_TYPE || element_type == FLOAT32_TYPE) {
+      uint8_t swizzle_mask = static_cast<uint8_t>(i.src2.value);
+      Xmm src1;
+      if (i.src1.is_constant) {
+        src1 = e.xmm0;
+        e.LoadConstantXmm(src1, i.src1.constant());
+      } else {
+        src1 = i.src1;
+      }
+      e.vpshufd(i.dest, src1, swizzle_mask);
+    } else if (element_type == INT64_TYPE || element_type == FLOAT64_TYPE) {
+      assert_always();
+    } else {
+      assert_always();
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_SWIZZLE, SWIZZLE);
+
+// ============================================================================
+// OPCODE_PACK
+// ============================================================================
+struct PACK : Sequence<PACK, I<OPCODE_PACK, V128Op, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    switch (i.instr->flags & PACK_TYPE_MODE) {
+      case PACK_TYPE_D3DCOLOR:
+        EmitD3DCOLOR(e, i);
+        break;
+      case PACK_TYPE_FLOAT16_2:
+        EmitFLOAT16_2(e, i);
+        break;
+      case PACK_TYPE_FLOAT16_4:
+        EmitFLOAT16_4(e, i);
+        break;
+      case PACK_TYPE_SHORT_2:
+        EmitSHORT_2(e, i);
+        break;
+      case PACK_TYPE_SHORT_4:
+        EmitSHORT_4(e, i);
+        break;
+      case PACK_TYPE_UINT_2101010:
+        EmitUINT_2101010(e, i);
+        break;
+      case PACK_TYPE_8_IN_16:
+        Emit8_IN_16(e, i, i.instr->flags);
+        break;
+      case PACK_TYPE_16_IN_32:
+        Emit16_IN_32(e, i, i.instr->flags);
+        break;
+      default:
+        assert_unhandled_case(i.instr->flags);
+        break;
+    }
+  }
+  static void EmitD3DCOLOR(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.value->IsConstantZero());
+    Xmm src;
+    if (i.src1.is_constant) {
+      src = i.dest;
+      e.LoadConstantXmm(src, i.src1.constant());
+    } else {
+      src = i.src1;
+    }
+    // Saturate to [3,3....] so that only values between 3...[00] and 3...[FF]
+    // are valid - max before min to pack NaN as zero (Red Dead Redemption is
+    // heavily affected by the order - packs 0xFFFFFFFF in matrix code to get 0
+    // constant).
+    e.vmaxps(i.dest, src, e.GetXmmConstPtr(XMM3333));
+    e.vminps(i.dest, i.dest, e.GetXmmConstPtr(XMMPackD3DCOLORSat));
+    // Extract bytes.
+    // RGBA (XYZW) -> ARGB (WXYZ)
+    // w = ((src1.uw & 0xFF) << 24) | ((src1.ux & 0xFF) << 16) |
+    //     ((src1.uy & 0xFF) << 8) | (src1.uz & 0xFF)
+    e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMPackD3DCOLOR));
+  }
+  static __m128i EmulateFLOAT16_2(void*, __m128 src1) {
+    alignas(16) float a[4];
+    alignas(16) uint16_t b[8];
+    _mm_store_ps(a, src1);
+    std::memset(b, 0, sizeof(b));
+
+    for (int i = 0; i < 2; i++) {
+      b[7 - i] = half_float::detail::float2half<std::round_toward_zero>(a[i]);
+    }
+
+    return _mm_load_si128(reinterpret_cast<__m128i*>(b));
+  }
+  static void EmitFLOAT16_2(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.value->IsConstantZero());
+    // http://blogs.msdn.com/b/chuckw/archive/2012/09/11/directxmath-f16c-and-fma.aspx
+    // dest = [(src1.x | src1.y), 0, 0, 0]
+
+    Xmm src;
+    if (e.IsFeatureEnabled(kX64EmitF16C)) {
+      if (i.src1.is_constant) {
+        src = i.dest;
+        e.LoadConstantXmm(src, i.src1.constant());
+      } else {
+        src = i.src1;
+      }
+      // 0|0|0|0|W|Z|Y|X
+      e.vcvtps2ph(i.dest, src, 0b00000011);
+      // Shuffle to X|Y|0|0|0|0|0|0
+      e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMPackFLOAT16_2));
+    } else {
+      if (i.src1.is_constant) {
+        src = e.xmm0;
+        e.LoadConstantXmm(src, i.src1.constant());
+      } else {
+        src = i.src1;
+      }
+      e.lea(e.GetNativeParam(0), e.StashXmm(0, src));
+      e.CallNativeSafe(reinterpret_cast<void*>(EmulateFLOAT16_2));
+      e.vmovaps(i.dest, e.xmm0);
+    }
+  }
+  static __m128i EmulateFLOAT16_4(void*, __m128 src1) {
+    alignas(16) float a[4];
+    alignas(16) uint16_t b[8];
+    _mm_store_ps(a, src1);
+    std::memset(b, 0, sizeof(b));
+
+    for (int i = 0; i < 4; i++) {
+      b[7 - (i ^ 2)] =
+          half_float::detail::float2half<std::round_toward_zero>(a[i]);
+    }
+
+    return _mm_load_si128(reinterpret_cast<__m128i*>(b));
+  }
+  static void EmitFLOAT16_4(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.value->IsConstantZero());
+    // dest = [(src1.z | src1.w), (src1.x | src1.y), 0, 0]
+
+    Xmm src;
+    if (e.IsFeatureEnabled(kX64EmitF16C)) {
+      if (i.src1.is_constant) {
+        src = i.dest;
+        e.LoadConstantXmm(src, i.src1.constant());
+      } else {
+        src = i.src1;
+      }
+      // 0|0|0|0|W|Z|Y|X
+      e.vcvtps2ph(i.dest, src, 0b00000011);
+      // Shuffle to Z|W|X|Y|0|0|0|0
+      e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMPackFLOAT16_4));
+    } else {
+      if (i.src1.is_constant) {
+        src = e.xmm0;
+        e.LoadConstantXmm(src, i.src1.constant());
+      } else {
+        src = i.src1;
+      }
+      e.lea(e.GetNativeParam(0), e.StashXmm(0, src));
+      e.CallNativeSafe(reinterpret_cast<void*>(EmulateFLOAT16_4));
+      e.vmovaps(i.dest, e.xmm0);
+    }
+  }
+  static void EmitSHORT_2(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.value->IsConstantZero());
+    Xmm src;
+    if (i.src1.is_constant) {
+      src = i.dest;
+      e.LoadConstantXmm(src, i.src1.constant());
+    } else {
+      src = i.src1;
+    }
+    // Saturate.
+    e.vmaxps(i.dest, src, e.GetXmmConstPtr(XMMPackSHORT_Min));
+    e.vminps(i.dest, i.dest, e.GetXmmConstPtr(XMMPackSHORT_Max));
+    // Pack.
+    e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMPackSHORT_2));
+  }
+  static void EmitSHORT_4(X64Emitter& e, const EmitArgType& i) {
+    assert_true(i.src2.value->IsConstantZero());
+    Xmm src;
+    if (i.src1.is_constant) {
+      src = i.dest;
+      e.LoadConstantXmm(src, i.src1.constant());
+    } else {
+      src = i.src1;
+    }
+    // Saturate.
+    e.vmaxps(i.dest, src, e.GetXmmConstPtr(XMMPackSHORT_Min));
+    e.vminps(i.dest, i.dest, e.GetXmmConstPtr(XMMPackSHORT_Max));
+    // Pack.
+    e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMPackSHORT_4));
+  }
+  static void EmitUINT_2101010(X64Emitter& e, const EmitArgType& i) {
+    // https://www.opengl.org/registry/specs/ARB/vertex_type_2_10_10_10_rev.txt
+    // XYZ are 10 bits, signed and saturated.
+    // W is 2 bits, unsigned and saturated.
+    Xmm src;
+    if (i.src1.is_constant) {
+      src = i.dest;
+      e.LoadConstantXmm(src, i.src1.constant());
+    } else {
+      src = i.src1;
+    }
+    // Saturate.
+    e.vmaxps(i.dest, src, e.GetXmmConstPtr(XMMPackUINT_2101010_MinUnpacked));
+    e.vminps(i.dest, i.dest, e.GetXmmConstPtr(XMMPackUINT_2101010_MaxUnpacked));
+    // Remove the unneeded bits of the floats.
+    e.vpand(i.dest, e.GetXmmConstPtr(XMMPackUINT_2101010_MaskUnpacked));
+    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
+      // Shift the components up.
+      e.vpsllvd(i.dest, i.dest, e.GetXmmConstPtr(XMMPackUINT_2101010_Shift));
+    } else {
+      // Duplicate all the components into bits 10-19.
+      e.vpslld(e.xmm0, i.dest, 10);
+      e.vpor(i.dest, e.xmm0);
+      // Duplicate all the components into bits 20-39
+      // (so alpha will be in 30-31).
+      e.vpslld(e.xmm0, i.dest, 20);
+      e.vpor(i.dest, e.xmm0);
+      // Leave only the needed components.
+      e.vpand(i.dest, e.GetXmmConstPtr(XMMPackUINT_2101010_MaskPacked));
+    }
+    // Combine the components.
+    e.vshufps(e.xmm0, i.dest, i.dest, _MM_SHUFFLE(2, 3, 0, 1));
+    e.vorps(i.dest, e.xmm0);
+    e.vshufps(e.xmm0, i.dest, i.dest, _MM_SHUFFLE(1, 0, 3, 2));
+    e.vorps(i.dest, e.xmm0);
+  }
+  static __m128i EmulatePack8_IN_16_UN_UN_SAT(void*, __m128i src1,
+                                              __m128i src2) {
+    alignas(16) uint16_t a[8];
+    alignas(16) uint16_t b[8];
+    alignas(16) uint8_t c[16];
+    _mm_store_si128(reinterpret_cast<__m128i*>(a), src1);
+    _mm_store_si128(reinterpret_cast<__m128i*>(b), src2);
+    for (int i = 0; i < 8; ++i) {
+      c[i] = uint8_t(std::max(uint16_t(0), std::min(uint16_t(255), a[i])));
+      c[i + 8] = uint8_t(std::max(uint16_t(0), std::min(uint16_t(255), b[i])));
+    }
+    return _mm_load_si128(reinterpret_cast<__m128i*>(c));
+  }
+  static __m128i EmulatePack8_IN_16_UN_UN(void*, __m128i src1, __m128i src2) {
+    alignas(16) uint8_t a[16];
+    alignas(16) uint8_t b[16];
+    alignas(16) uint8_t c[16];
+    _mm_store_si128(reinterpret_cast<__m128i*>(a), src1);
+    _mm_store_si128(reinterpret_cast<__m128i*>(b), src2);
+    for (int i = 0; i < 8; ++i) {
+      c[i] = a[i * 2];
+      c[i + 8] = b[i * 2];
+    }
+    return _mm_load_si128(reinterpret_cast<__m128i*>(c));
+  }
+  static void Emit8_IN_16(X64Emitter& e, const EmitArgType& i, uint32_t flags) {
+    // TODO(benvanik): handle src2 (or src1) being constant zero
+    if (IsPackInUnsigned(flags)) {
+      if (IsPackOutUnsigned(flags)) {
+        if (IsPackOutSaturate(flags)) {
+          // unsigned -> unsigned + saturate
+          if (i.src2.is_constant) {
+            e.LoadConstantXmm(e.xmm0, i.src2.constant());
+            e.lea(e.GetNativeParam(1), e.StashXmm(1, e.xmm0));
+          } else {
+            e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+          }
+          e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
+          e.CallNativeSafe(
+              reinterpret_cast<void*>(EmulatePack8_IN_16_UN_UN_SAT));
+          e.vmovaps(i.dest, e.xmm0);
+          e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMByteOrderMask));
+        } else {
+          // unsigned -> unsigned
+          e.lea(e.GetNativeParam(1), e.StashXmm(1, i.src2));
+          e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
+          e.CallNativeSafe(reinterpret_cast<void*>(EmulatePack8_IN_16_UN_UN));
+          e.vmovaps(i.dest, e.xmm0);
+          e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMByteOrderMask));
+        }
+      } else {
+        if (IsPackOutSaturate(flags)) {
+          // unsigned -> signed + saturate
+          assert_always();
+        } else {
+          // unsigned -> signed
+          assert_always();
+        }
+      }
+    } else {
+      if (IsPackOutUnsigned(flags)) {
+        if (IsPackOutSaturate(flags)) {
+          // signed -> unsigned + saturate
+          // PACKUSWB / SaturateSignedWordToUnsignedByte
+          Xbyak::Xmm src2 = i.src2.is_constant ? e.xmm0 : i.src2;
+          if (i.src2.is_constant) {
+            e.LoadConstantXmm(src2, i.src2.constant());
+          }
+
+          e.vpackuswb(i.dest, i.src1, src2);
+          e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMByteOrderMask));
+        } else {
+          // signed -> unsigned
+          assert_always();
+        }
+      } else {
+        if (IsPackOutSaturate(flags)) {
+          // signed -> signed + saturate
+          // PACKSSWB / SaturateSignedWordToSignedByte
+          e.vpacksswb(i.dest, i.src1, i.src2);
+          e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMByteOrderMask));
+        } else {
+          // signed -> signed
+          assert_always();
+        }
+      }
+    }
+  }
+  // Pack 2 32-bit vectors into a 16-bit vector.
+  static void Emit16_IN_32(X64Emitter& e, const EmitArgType& i,
+                           uint32_t flags) {
+    // TODO(benvanik): handle src2 (or src1) being constant zero
+    if (IsPackInUnsigned(flags)) {
+      if (IsPackOutUnsigned(flags)) {
+        if (IsPackOutSaturate(flags)) {
+          // unsigned -> unsigned + saturate
+          // Construct a saturation max value
+          e.mov(e.eax, 0xFFFFu);
+          e.vmovd(e.xmm0, e.eax);
+          e.vpshufd(e.xmm0, e.xmm0, 0b00000000);
+
+          if (!i.src1.is_constant) {
+            e.vpminud(e.xmm1, i.src1, e.xmm0);  // Saturate src1
+            e.vpshuflw(e.xmm1, e.xmm1, 0b00100010);
+            e.vpshufhw(e.xmm1, e.xmm1, 0b00100010);
+            e.vpshufd(e.xmm1, e.xmm1, 0b00001000);
+          } else {
+            // TODO(DrChat): Non-zero constants
+            assert_true(i.src1.constant().u64[0] == 0 &&
+                        i.src1.constant().u64[1] == 0);
+            e.vpxor(e.xmm1, e.xmm1);
+          }
+
+          if (!i.src2.is_constant) {
+            e.vpminud(i.dest, i.src2, e.xmm0);  // Saturate src2
+            e.vpshuflw(i.dest, i.dest, 0b00100010);
+            e.vpshufhw(i.dest, i.dest, 0b00100010);
+            e.vpshufd(i.dest, i.dest, 0b10000000);
+          } else {
+            // TODO(DrChat): Non-zero constants
+            assert_true(i.src2.constant().u64[0] == 0 &&
+                        i.src2.constant().u64[1] == 0);
+            e.vpxor(i.dest, i.dest);
+          }
+
+          e.vpblendw(i.dest, i.dest, e.xmm1, 0b00001111);
+        } else {
+          // unsigned -> unsigned
+          e.vmovaps(e.xmm0, i.src1);
+          e.vpshuflw(e.xmm0, e.xmm0, 0b00100010);
+          e.vpshufhw(e.xmm0, e.xmm0, 0b00100010);
+          e.vpshufd(e.xmm0, e.xmm0, 0b00001000);
+
+          e.vmovaps(i.dest, i.src2);
+          e.vpshuflw(i.dest, i.dest, 0b00100010);
+          e.vpshufhw(i.dest, i.dest, 0b00100010);
+          e.vpshufd(i.dest, i.dest, 0b10000000);
+
+          e.vpblendw(i.dest, i.dest, e.xmm0, 0b00001111);
+        }
+      } else {
+        if (IsPackOutSaturate(flags)) {
+          // unsigned -> signed + saturate
+          assert_always();
+        } else {
+          // unsigned -> signed
+          assert_always();
+        }
+      }
+    } else {
+      if (IsPackOutUnsigned(flags)) {
+        if (IsPackOutSaturate(flags)) {
+          // signed -> unsigned + saturate
+          // PACKUSDW
+          // TMP[15:0] <- (DEST[31:0] < 0) ? 0 : DEST[15:0];
+          // DEST[15:0] <- (DEST[31:0] > FFFFH) ? FFFFH : TMP[15:0];
+          e.vpackusdw(i.dest, i.src1, i.src2);
+          e.vpshuflw(i.dest, i.dest, 0b10110001);
+          e.vpshufhw(i.dest, i.dest, 0b10110001);
+        } else {
+          // signed -> unsigned
+          assert_always();
+        }
+      } else {
+        if (IsPackOutSaturate(flags)) {
+          // signed -> signed + saturate
+          // PACKSSDW / SaturateSignedDwordToSignedWord
+          Xmm src2;
+          if (!i.src2.is_constant) {
+            src2 = i.src2;
+          } else {
+            assert_false(i.src1 == e.xmm0);
+            src2 = e.xmm0;
+            e.LoadConstantXmm(src2, i.src2.constant());
+          }
+          e.vpackssdw(i.dest, i.src1, src2);
+          e.vpshuflw(i.dest, i.dest, 0b10110001);
+          e.vpshufhw(i.dest, i.dest, 0b10110001);
+        } else {
+          // signed -> signed
+          assert_always();
+        }
+      }
+    }
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_PACK, PACK);
+
+// ============================================================================
+// OPCODE_UNPACK
+// ============================================================================
+struct UNPACK : Sequence<UNPACK, I<OPCODE_UNPACK, V128Op, V128Op>> {
+  static void Emit(X64Emitter& e, const EmitArgType& i) {
+    switch (i.instr->flags & PACK_TYPE_MODE) {
+      case PACK_TYPE_D3DCOLOR:
+        EmitD3DCOLOR(e, i);
+        break;
+      case PACK_TYPE_FLOAT16_2:
+        EmitFLOAT16_2(e, i);
+        break;
+      case PACK_TYPE_FLOAT16_4:
+        EmitFLOAT16_4(e, i);
+        break;
+      case PACK_TYPE_SHORT_2:
+        EmitSHORT_2(e, i);
+        break;
+      case PACK_TYPE_SHORT_4:
+        EmitSHORT_4(e, i);
+        break;
+      case PACK_TYPE_UINT_2101010:
+        EmitUINT_2101010(e, i);
+        break;
+      case PACK_TYPE_8_IN_16:
+        Emit8_IN_16(e, i, i.instr->flags);
+        break;
+      case PACK_TYPE_16_IN_32:
+        Emit16_IN_32(e, i, i.instr->flags);
+        break;
+      default:
+        assert_unhandled_case(i.instr->flags);
+        break;
+    }
+  }
+  static void EmitD3DCOLOR(X64Emitter& e, const EmitArgType& i) {
+    // ARGB (WXYZ) -> RGBA (XYZW)
+    Xmm src;
+    if (i.src1.is_constant) {
+      if (i.src1.value->IsConstantZero()) {
+        e.vmovaps(i.dest, e.GetXmmConstPtr(XMMOne));
+        return;
+      }
+      src = i.dest;
+      e.LoadConstantXmm(src, i.src1.constant());
+    } else {
+      src = i.src1;
+    }
+    // src = ZZYYXXWW
+    // Unpack to 000000ZZ,000000YY,000000XX,000000WW
+    e.vpshufb(i.dest, src, e.GetXmmConstPtr(XMMUnpackD3DCOLOR));
+    // Add 1.0f to each.
+    e.vpor(i.dest, e.GetXmmConstPtr(XMMOne));
+    // To convert to 0 to 1, games multiply by 0x47008081 and add 0xC7008081.
+  }
+  static __m128 EmulateFLOAT16_2(void*, __m128i src1) {
+    alignas(16) uint16_t a[8];
+    alignas(16) float b[4];
+    _mm_store_si128(reinterpret_cast<__m128i*>(a), src1);
+
+    for (int i = 0; i < 2; i++) {
+      b[i] = half_float::detail::half2float(a[VEC128_W(6 + i)]);
+    }
+
+    // Constants, or something
+    b[2] = 0.f;
+    b[3] = 1.f;
+
+    return _mm_load_ps(b);
+  }
+  static void EmitFLOAT16_2(X64Emitter& e, const EmitArgType& i) {
+    // 1 bit sign, 5 bit exponent, 10 bit mantissa
+    // D3D10 half float format
+    // TODO(benvanik):
+    // http://blogs.msdn.com/b/chuckw/archive/2012/09/11/directxmath-f16c-and-fma.aspx
+    // Use _mm_cvtph_ps -- requires very modern processors (SSE5+)
+    // Unpacking half floats:
+    // http://fgiesen.wordpress.com/2012/03/28/half-to-float-done-quic/
+    // Packing half floats: https://gist.github.com/rygorous/2156668
+    // Load source, move from tight pack of X16Y16.... to X16...Y16...
+    // Also zero out the high end.
+    // TODO(benvanik): special case constant unpacks that just get 0/1/etc.
+
+    Xmm src;
+    if (e.IsFeatureEnabled(kX64EmitF16C)) {
+      if (i.src1.is_constant) {
+        src = i.dest;
+        e.LoadConstantXmm(src, i.src1.constant());
+      } else {
+        src = i.src1;
+      }
+      // sx = src.iw >> 16;
+      // sy = src.iw & 0xFFFF;
+      // dest = { XMConvertHalfToFloat(sx),
+      //          XMConvertHalfToFloat(sy),
+      //          0.0,
+      //          1.0 };
+      // Shuffle to 0|0|0|0|0|0|Y|X
+      e.vpshufb(i.dest, src, e.GetXmmConstPtr(XMMUnpackFLOAT16_2));
+      e.vcvtph2ps(i.dest, i.dest);
+      e.vpshufd(i.dest, i.dest, 0b10100100);
+      e.vpor(i.dest, e.GetXmmConstPtr(XMM0001));
+    } else {
+      if (i.src1.is_constant) {
+        src = e.xmm0;
+        e.LoadConstantXmm(src, i.src1.constant());
+      } else {
+        src = i.src1;
+      }
+      e.lea(e.GetNativeParam(0), e.StashXmm(0, src));
+      e.CallNativeSafe(reinterpret_cast<void*>(EmulateFLOAT16_2));
+      e.vmovaps(i.dest, e.xmm0);
+    }
+  }
+  static __m128 EmulateFLOAT16_4(void*, __m128i src1) {
+    alignas(16) uint16_t a[8];
+    alignas(16) float b[4];
+    _mm_store_si128(reinterpret_cast<__m128i*>(a), src1);
+
+    for (int i = 0; i < 4; i++) {
+      b[i] = half_float::detail::half2float(a[VEC128_W(4 + i)]);
+    }
+
+    return _mm_load_ps(b);
+  }
+  static void EmitFLOAT16_4(X64Emitter& e, const EmitArgType& i) {
+    // src = [(dest.x | dest.y), (dest.z | dest.w), 0, 0]
+    Xmm src;
+    if (e.IsFeatureEnabled(kX64EmitF16C)) {
+      if (i.src1.is_constant) {
+        src = i.dest;
+        e.LoadConstantXmm(src, i.src1.constant());
+      } else {
+        src = i.src1;
+      }
+      // Shuffle to 0|0|0|0|W|Z|Y|X
+      e.vpshufb(i.dest, src, e.GetXmmConstPtr(XMMUnpackFLOAT16_4));
+      e.vcvtph2ps(i.dest, i.dest);
+    } else {
+      if (i.src1.is_constant) {
+        src = e.xmm0;
+        e.LoadConstantXmm(src, i.src1.constant());
+      } else {
+        src = i.src1;
+      }
+      e.lea(e.GetNativeParam(0), e.StashXmm(0, src));
+      e.CallNativeSafe(reinterpret_cast<void*>(EmulateFLOAT16_4));
+      e.vmovaps(i.dest, e.xmm0);
+    }
+  }
+  static void EmitSHORT_2(X64Emitter& e, const EmitArgType& i) {
+    // (VD.x) = 3.0 + (VB.x>>16)*2^-22
+    // (VD.y) = 3.0 + (VB.x)*2^-22
+    // (VD.z) = 0.0
+    // (VD.w) = 1.0 (games splat W after unpacking to get vectors of 1.0f)
+    // src is (xx,xx,xx,VALUE)
+    Xmm src;
+    if (i.src1.is_constant) {
+      if (i.src1.value->IsConstantZero()) {
+        e.vmovdqa(i.dest, e.GetXmmConstPtr(XMM3301));
+        return;
+      }
+      // TODO(benvanik): check other common constants/perform shuffle/or here.
+      src = i.dest;
+      e.LoadConstantXmm(src, i.src1.constant());
+    } else {
+      src = i.src1;
+    }
+    // Shuffle bytes.
+    e.vpshufb(i.dest, src, e.GetXmmConstPtr(XMMUnpackSHORT_2));
+    // If negative, make smaller than 3 - sign extend before adding.
+    e.vpslld(i.dest, 16);
+    e.vpsrad(i.dest, 16);
+    // Add 3,3,0,1.
+    e.vpaddd(i.dest, e.GetXmmConstPtr(XMM3301));
+    // Return quiet NaNs in case of negative overflow.
+    e.vcmpeqps(e.xmm0, i.dest, e.GetXmmConstPtr(XMMUnpackSHORT_Overflow));
+    e.vblendvps(i.dest, i.dest, e.GetXmmConstPtr(XMMUnpackOverflowNaN), e.xmm0);
+  }
+  static void EmitSHORT_4(X64Emitter& e, const EmitArgType& i) {
+    // (VD.x) = 3.0 + (VB.x>>16)*2^-22
+    // (VD.y) = 3.0 + (VB.x)*2^-22
+    // (VD.z) = 3.0 + (VB.y>>16)*2^-22
+    // (VD.w) = 3.0 + (VB.y)*2^-22
+    // src is (xx,xx,VALUE,VALUE)
+    Xmm src;
+    if (i.src1.is_constant) {
+      if (i.src1.value->IsConstantZero()) {
+        e.vmovdqa(i.dest, e.GetXmmConstPtr(XMM3333));
+        return;
+      }
+      // TODO(benvanik): check other common constants/perform shuffle/or here.
+      src = i.dest;
+      e.LoadConstantXmm(src, i.src1.constant());
+    } else {
+      src = i.src1;
+    }
+    // Shuffle bytes.
+    e.vpshufb(i.dest, src, e.GetXmmConstPtr(XMMUnpackSHORT_4));
+    // If negative, make smaller than 3 - sign extend before adding.
+    e.vpslld(i.dest, 16);
+    e.vpsrad(i.dest, 16);
+    // Add 3,3,3,3.
+    e.vpaddd(i.dest, e.GetXmmConstPtr(XMM3333));
+    // Return quiet NaNs in case of negative overflow.
+    e.vcmpeqps(e.xmm0, i.dest, e.GetXmmConstPtr(XMMUnpackSHORT_Overflow));
+    e.vblendvps(i.dest, i.dest, e.GetXmmConstPtr(XMMUnpackOverflowNaN), e.xmm0);
+  }
+  static void EmitUINT_2101010(X64Emitter& e, const EmitArgType& i) {
+    Xmm src;
+    if (i.src1.is_constant) {
+      if (i.src1.value->IsConstantZero()) {
+        e.vmovdqa(i.dest, e.GetXmmConstPtr(XMM3331));
+        return;
+      }
+      src = i.dest;
+      e.LoadConstantXmm(src, i.src1.constant());
+    } else {
+      src = i.src1;
+    }
+    // Splat W.
+    e.vshufps(i.dest, src, src, _MM_SHUFFLE(3, 3, 3, 3));
+    // Keep only the needed components.
+    // Red in 0-9 now, green in 10-19, blue in 20-29, alpha in 30-31.
+    e.vpand(i.dest, e.GetXmmConstPtr(XMMPackUINT_2101010_MaskPacked));
+    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
+      // Shift the components down.
+      e.vpsrlvd(i.dest, i.dest, e.GetXmmConstPtr(XMMPackUINT_2101010_Shift));
+    } else {
+      // Duplicate green in 0-9 and alpha in 20-21.
+      e.vpsrld(e.xmm0, i.dest, 10);
+      e.vpor(i.dest, e.xmm0);
+      // Duplicate blue in 0-9 and alpha in 0-1.
+      e.vpsrld(e.xmm0, i.dest, 20);
+      e.vpor(i.dest, e.xmm0);
+      // Remove higher duplicate components.
+      e.vpand(i.dest, e.GetXmmConstPtr(XMMPackUINT_2101010_MaskUnpacked));
+    }
+    // If XYZ are negative, make smaller than 3 - sign extend XYZ before adding.
+    // W is unsigned.
+    e.vpslld(i.dest, 22);
+    e.vpsrad(i.dest, 22);
+    // Add 3,3,3,1.
+    e.vpaddd(i.dest, e.GetXmmConstPtr(XMM3331));
+    // Return quiet NaNs in case of negative overflow.
+    e.vcmpeqps(e.xmm0, i.dest,
+               e.GetXmmConstPtr(XMMUnpackUINT_2101010_Overflow));
+    e.vblendvps(i.dest, i.dest, e.GetXmmConstPtr(XMMUnpackOverflowNaN), e.xmm0);
+    // To convert XYZ to -1 to 1, games multiply by 0x46004020 & sub 0x46C06030.
+    // For W to 0 to 1, they multiply by and subtract 0x4A2AAAAB.
+  }
+  static void Emit8_IN_16(X64Emitter& e, const EmitArgType& i, uint32_t flags) {
+    assert_false(IsPackOutSaturate(flags));
+    Xmm src;
+    if (i.src1.is_constant) {
+      src = i.dest;
+      e.LoadConstantXmm(src, i.src1.constant());
+    } else {
+      src = i.src1;
+    }
+    if (IsPackToLo(flags)) {
+      // Unpack to LO.
+      if (IsPackInUnsigned(flags)) {
+        if (IsPackOutUnsigned(flags)) {
+          // unsigned -> unsigned
+          assert_always();
+        } else {
+          // unsigned -> signed
+          assert_always();
+        }
+      } else {
+        if (IsPackOutUnsigned(flags)) {
+          // signed -> unsigned
+          assert_always();
+        } else {
+          // signed -> signed
+          e.vpshufb(i.dest, src, e.GetXmmConstPtr(XMMByteOrderMask));
+          e.vpunpckhbw(i.dest, i.dest, i.dest);
+          e.vpsraw(i.dest, 8);
+        }
+      }
+    } else {
+      // Unpack to HI.
+      if (IsPackInUnsigned(flags)) {
+        if (IsPackOutUnsigned(flags)) {
+          // unsigned -> unsigned
+          assert_always();
+        } else {
+          // unsigned -> signed
+          assert_always();
+        }
+      } else {
+        if (IsPackOutUnsigned(flags)) {
+          // signed -> unsigned
+          assert_always();
+        } else {
+          // signed -> signed
+          e.vpshufb(i.dest, src, e.GetXmmConstPtr(XMMByteOrderMask));
+          e.vpunpcklbw(i.dest, i.dest, i.dest);
+          e.vpsraw(i.dest, 8);
+        }
+      }
+    }
+  }
+  static void Emit16_IN_32(X64Emitter& e, const EmitArgType& i,
+                           uint32_t flags) {
+    assert_false(IsPackOutSaturate(flags));
+    Xmm src;
+    if (i.src1.is_constant) {
+      src = i.dest;
+      e.LoadConstantXmm(src, i.src1.constant());
+    } else {
+      src = i.src1;
+    }
+    if (IsPackToLo(flags)) {
+      // Unpack to LO.
+      if (IsPackInUnsigned(flags)) {
+        if (IsPackOutUnsigned(flags)) {
+          // unsigned -> unsigned
+          assert_always();
+        } else {
+          // unsigned -> signed
+          assert_always();
+        }
+      } else {
+        if (IsPackOutUnsigned(flags)) {
+          // signed -> unsigned
+          assert_always();
+        } else {
+          // signed -> signed
+          e.vpunpckhwd(i.dest, src, src);
+          e.vpsrad(i.dest, 16);
+        }
+      }
+    } else {
+      // Unpack to HI.
+      if (IsPackInUnsigned(flags)) {
+        if (IsPackOutUnsigned(flags)) {
+          // unsigned -> unsigned
+          assert_always();
+        } else {
+          // unsigned -> signed
+          assert_always();
+        }
+      } else {
+        if (IsPackOutUnsigned(flags)) {
+          // signed -> unsigned
+          assert_always();
+        } else {
+          // signed -> signed
+          e.vpunpcklwd(i.dest, src, src);
+          e.vpsrad(i.dest, 16);
+        }
+      }
+    }
+    e.vpshufd(i.dest, i.dest, 0xB1);
+  }
+};
+EMITTER_OPCODE_TABLE(OPCODE_UNPACK, UNPACK);
+
+}  // namespace x64
+}  // namespace backend
+}  // namespace cpu
+}  // namespace xe
\ No newline at end of file
diff --git a/src/xenia/cpu/backend/x64/x64_sequences.cc b/src/xenia/cpu/backend/x64/x64_sequences.cc
index ddf61c693..7d18cb4d0 100644
--- a/src/xenia/cpu/backend/x64/x64_sequences.cc
+++ b/src/xenia/cpu/backend/x64/x64_sequences.cc
@@ -33,13 +33,11 @@
 #include "xenia/base/logging.h"
 #include "xenia/base/threading.h"
 #include "xenia/cpu/backend/x64/x64_emitter.h"
+#include "xenia/cpu/backend/x64/x64_op.h"
 #include "xenia/cpu/backend/x64/x64_tracers.h"
 #include "xenia/cpu/hir/hir_builder.h"
 #include "xenia/cpu/processor.h"
 
-// For OPCODE_PACK/OPCODE_UNPACK
-#include "third_party/half/include/half.hpp"
-
 namespace xe {
 namespace cpu {
 namespace backend {
@@ -56,616 +54,6 @@ using xe::cpu::hir::Instr;
 typedef bool (*SequenceSelectFn)(X64Emitter&, const Instr*);
 std::unordered_map<uint32_t, SequenceSelectFn> sequence_table;
 
-// Selects the right byte/word/etc from a vector. We need to flip logical
-// indices (0,1,2,3,4,5,6,7,...) = (3,2,1,0,7,6,5,4,...)
-#define VEC128_B(n) ((n) ^ 0x3)
-#define VEC128_W(n) ((n) ^ 0x1)
-#define VEC128_D(n) (n)
-#define VEC128_F(n) (n)
-
-enum KeyType {
-  KEY_TYPE_X = OPCODE_SIG_TYPE_X,
-  KEY_TYPE_L = OPCODE_SIG_TYPE_L,
-  KEY_TYPE_O = OPCODE_SIG_TYPE_O,
-  KEY_TYPE_S = OPCODE_SIG_TYPE_S,
-  KEY_TYPE_V_I8 = OPCODE_SIG_TYPE_V + INT8_TYPE,
-  KEY_TYPE_V_I16 = OPCODE_SIG_TYPE_V + INT16_TYPE,
-  KEY_TYPE_V_I32 = OPCODE_SIG_TYPE_V + INT32_TYPE,
-  KEY_TYPE_V_I64 = OPCODE_SIG_TYPE_V + INT64_TYPE,
-  KEY_TYPE_V_F32 = OPCODE_SIG_TYPE_V + FLOAT32_TYPE,
-  KEY_TYPE_V_F64 = OPCODE_SIG_TYPE_V + FLOAT64_TYPE,
-  KEY_TYPE_V_V128 = OPCODE_SIG_TYPE_V + VEC128_TYPE,
-};
-
-#pragma pack(push, 1)
-union InstrKey {
-  struct {
-    uint32_t opcode : 8;
-    uint32_t dest : 5;
-    uint32_t src1 : 5;
-    uint32_t src2 : 5;
-    uint32_t src3 : 5;
-    uint32_t reserved : 4;
-  };
-  uint32_t value;
-
-  operator uint32_t() const { return value; }
-
-  InstrKey() : value(0) {}
-  InstrKey(uint32_t v) : value(v) {}
-  InstrKey(const Instr* i) : value(0) {
-    opcode = i->opcode->num;
-    uint32_t sig = i->opcode->signature;
-    dest =
-        GET_OPCODE_SIG_TYPE_DEST(sig) ? OPCODE_SIG_TYPE_V + i->dest->type : 0;
-    src1 = GET_OPCODE_SIG_TYPE_SRC1(sig);
-    if (src1 == OPCODE_SIG_TYPE_V) {
-      src1 += i->src1.value->type;
-    }
-    src2 = GET_OPCODE_SIG_TYPE_SRC2(sig);
-    if (src2 == OPCODE_SIG_TYPE_V) {
-      src2 += i->src2.value->type;
-    }
-    src3 = GET_OPCODE_SIG_TYPE_SRC3(sig);
-    if (src3 == OPCODE_SIG_TYPE_V) {
-      src3 += i->src3.value->type;
-    }
-  }
-
-  template <Opcode OPCODE, KeyType DEST = KEY_TYPE_X, KeyType SRC1 = KEY_TYPE_X,
-            KeyType SRC2 = KEY_TYPE_X, KeyType SRC3 = KEY_TYPE_X>
-  struct Construct {
-    static const uint32_t value =
-        (OPCODE) | (DEST << 8) | (SRC1 << 13) | (SRC2 << 18) | (SRC3 << 23);
-  };
-};
-#pragma pack(pop)
-static_assert(sizeof(InstrKey) <= 4, "Key must be 4 bytes");
-
-template <typename... Ts>
-struct CombinedStruct;
-template <>
-struct CombinedStruct<> {};
-template <typename T, typename... Ts>
-struct CombinedStruct<T, Ts...> : T, CombinedStruct<Ts...> {};
-
-struct OpBase {};
-
-template <typename T, KeyType KEY_TYPE>
-struct Op : OpBase {
-  static const KeyType key_type = KEY_TYPE;
-};
-
-struct VoidOp : Op<VoidOp, KEY_TYPE_X> {
- protected:
-  template <typename T, KeyType KEY_TYPE>
-  friend struct Op;
-  template <hir::Opcode OPCODE, typename... Ts>
-  friend struct I;
-  void Load(const Instr::Op& op) {}
-};
-
-struct OffsetOp : Op<OffsetOp, KEY_TYPE_O> {
-  uint64_t value;
-
- protected:
-  template <typename T, KeyType KEY_TYPE>
-  friend struct Op;
-  template <hir::Opcode OPCODE, typename... Ts>
-  friend struct I;
-  void Load(const Instr::Op& op) { this->value = op.offset; }
-};
-
-struct SymbolOp : Op<SymbolOp, KEY_TYPE_S> {
-  Function* value;
-
- protected:
-  template <typename T, KeyType KEY_TYPE>
-  friend struct Op;
-  template <hir::Opcode OPCODE, typename... Ts>
-  friend struct I;
-  bool Load(const Instr::Op& op) {
-    this->value = op.symbol;
-    return true;
-  }
-};
-
-struct LabelOp : Op<LabelOp, KEY_TYPE_L> {
-  hir::Label* value;
-
- protected:
-  template <typename T, KeyType KEY_TYPE>
-  friend struct Op;
-  template <hir::Opcode OPCODE, typename... Ts>
-  friend struct I;
-  void Load(const Instr::Op& op) { this->value = op.label; }
-};
-
-template <typename T, KeyType KEY_TYPE, typename REG_TYPE, typename CONST_TYPE>
-struct ValueOp : Op<ValueOp<T, KEY_TYPE, REG_TYPE, CONST_TYPE>, KEY_TYPE> {
-  typedef REG_TYPE reg_type;
-  const Value* value;
-  bool is_constant;
-  virtual bool ConstantFitsIn32Reg() const { return true; }
-  const REG_TYPE& reg() const {
-    assert_true(!is_constant);
-    return reg_;
-  }
-  operator const REG_TYPE&() const { return reg(); }
-  bool IsEqual(const T& b) const {
-    if (is_constant && b.is_constant) {
-      return reinterpret_cast<const T*>(this)->constant() == b.constant();
-    } else if (!is_constant && !b.is_constant) {
-      return reg_.getIdx() == b.reg_.getIdx();
-    } else {
-      return false;
-    }
-  }
-  bool IsEqual(const Xbyak::Reg& b) const {
-    if (is_constant) {
-      return false;
-    } else if (!is_constant) {
-      return reg_.getIdx() == b.getIdx();
-    } else {
-      return false;
-    }
-  }
-  bool operator==(const T& b) const { return IsEqual(b); }
-  bool operator!=(const T& b) const { return !IsEqual(b); }
-  bool operator==(const Xbyak::Reg& b) const { return IsEqual(b); }
-  bool operator!=(const Xbyak::Reg& b) const { return !IsEqual(b); }
-  void Load(const Instr::Op& op) {
-    value = op.value;
-    is_constant = value->IsConstant();
-    if (!is_constant) {
-      X64Emitter::SetupReg(value, reg_);
-    }
-  }
-
- protected:
-  REG_TYPE reg_;
-};
-
-struct I8Op : ValueOp<I8Op, KEY_TYPE_V_I8, Reg8, int8_t> {
-  typedef ValueOp<I8Op, KEY_TYPE_V_I8, Reg8, int8_t> BASE;
-  const int8_t constant() const {
-    assert_true(BASE::is_constant);
-    return BASE::value->constant.i8;
-  }
-};
-struct I16Op : ValueOp<I16Op, KEY_TYPE_V_I16, Reg16, int16_t> {
-  typedef ValueOp<I16Op, KEY_TYPE_V_I16, Reg16, int16_t> BASE;
-  const int16_t constant() const {
-    assert_true(BASE::is_constant);
-    return BASE::value->constant.i16;
-  }
-};
-struct I32Op : ValueOp<I32Op, KEY_TYPE_V_I32, Reg32, int32_t> {
-  typedef ValueOp<I32Op, KEY_TYPE_V_I32, Reg32, int32_t> BASE;
-  const int32_t constant() const {
-    assert_true(BASE::is_constant);
-    return BASE::value->constant.i32;
-  }
-};
-struct I64Op : ValueOp<I64Op, KEY_TYPE_V_I64, Reg64, int64_t> {
-  typedef ValueOp<I64Op, KEY_TYPE_V_I64, Reg64, int64_t> BASE;
-  const int64_t constant() const {
-    assert_true(BASE::is_constant);
-    return BASE::value->constant.i64;
-  }
-  bool ConstantFitsIn32Reg() const override {
-    int64_t v = BASE::value->constant.i64;
-    if ((v & ~0x7FFFFFFF) == 0) {
-      // Fits under 31 bits, so just load using normal mov.
-      return true;
-    } else if ((v & ~0x7FFFFFFF) == ~0x7FFFFFFF) {
-      // Negative number that fits in 32bits.
-      return true;
-    }
-    return false;
-  }
-};
-struct F32Op : ValueOp<F32Op, KEY_TYPE_V_F32, Xmm, float> {
-  typedef ValueOp<F32Op, KEY_TYPE_V_F32, Xmm, float> BASE;
-  const float constant() const {
-    assert_true(BASE::is_constant);
-    return BASE::value->constant.f32;
-  }
-};
-struct F64Op : ValueOp<F64Op, KEY_TYPE_V_F64, Xmm, double> {
-  typedef ValueOp<F64Op, KEY_TYPE_V_F64, Xmm, double> BASE;
-  const double constant() const {
-    assert_true(BASE::is_constant);
-    return BASE::value->constant.f64;
-  }
-};
-struct V128Op : ValueOp<V128Op, KEY_TYPE_V_V128, Xmm, vec128_t> {
-  typedef ValueOp<V128Op, KEY_TYPE_V_V128, Xmm, vec128_t> BASE;
-  const vec128_t& constant() const {
-    assert_true(BASE::is_constant);
-    return BASE::value->constant.v128;
-  }
-};
-
-template <typename DEST, typename... Tf>
-struct DestField;
-template <typename DEST>
-struct DestField<DEST> {
-  DEST dest;
-
- protected:
-  bool LoadDest(const Instr* i) {
-    Instr::Op op;
-    op.value = i->dest;
-    dest.Load(op);
-    return true;
-  }
-};
-template <>
-struct DestField<VoidOp> {
- protected:
-  bool LoadDest(const Instr* i) { return true; }
-};
-
-template <hir::Opcode OPCODE, typename... Ts>
-struct I;
-template <hir::Opcode OPCODE, typename DEST>
-struct I<OPCODE, DEST> : DestField<DEST> {
-  typedef DestField<DEST> BASE;
-  static const hir::Opcode opcode = OPCODE;
-  static const uint32_t key =
-      InstrKey::Construct<OPCODE, DEST::key_type>::value;
-  static const KeyType dest_type = DEST::key_type;
-  const Instr* instr;
-
- protected:
-  template <typename SEQ, typename T>
-  friend struct Sequence;
-  bool Load(const Instr* i) {
-    if (InstrKey(i).value == key && BASE::LoadDest(i)) {
-      instr = i;
-      return true;
-    }
-    return false;
-  }
-};
-template <hir::Opcode OPCODE, typename DEST, typename SRC1>
-struct I<OPCODE, DEST, SRC1> : DestField<DEST> {
-  typedef DestField<DEST> BASE;
-  static const hir::Opcode opcode = OPCODE;
-  static const uint32_t key =
-      InstrKey::Construct<OPCODE, DEST::key_type, SRC1::key_type>::value;
-  static const KeyType dest_type = DEST::key_type;
-  static const KeyType src1_type = SRC1::key_type;
-  const Instr* instr;
-  SRC1 src1;
-
- protected:
-  template <typename SEQ, typename T>
-  friend struct Sequence;
-  bool Load(const Instr* i) {
-    if (InstrKey(i).value == key && BASE::LoadDest(i)) {
-      instr = i;
-      src1.Load(i->src1);
-      return true;
-    }
-    return false;
-  }
-};
-template <hir::Opcode OPCODE, typename DEST, typename SRC1, typename SRC2>
-struct I<OPCODE, DEST, SRC1, SRC2> : DestField<DEST> {
-  typedef DestField<DEST> BASE;
-  static const hir::Opcode opcode = OPCODE;
-  static const uint32_t key =
-      InstrKey::Construct<OPCODE, DEST::key_type, SRC1::key_type,
-                          SRC2::key_type>::value;
-  static const KeyType dest_type = DEST::key_type;
-  static const KeyType src1_type = SRC1::key_type;
-  static const KeyType src2_type = SRC2::key_type;
-  const Instr* instr;
-  SRC1 src1;
-  SRC2 src2;
-
- protected:
-  template <typename SEQ, typename T>
-  friend struct Sequence;
-  bool Load(const Instr* i) {
-    if (InstrKey(i).value == key && BASE::LoadDest(i)) {
-      instr = i;
-      src1.Load(i->src1);
-      src2.Load(i->src2);
-      return true;
-    }
-    return false;
-  }
-};
-template <hir::Opcode OPCODE, typename DEST, typename SRC1, typename SRC2,
-          typename SRC3>
-struct I<OPCODE, DEST, SRC1, SRC2, SRC3> : DestField<DEST> {
-  typedef DestField<DEST> BASE;
-  static const hir::Opcode opcode = OPCODE;
-  static const uint32_t key =
-      InstrKey::Construct<OPCODE, DEST::key_type, SRC1::key_type,
-                          SRC2::key_type, SRC3::key_type>::value;
-  static const KeyType dest_type = DEST::key_type;
-  static const KeyType src1_type = SRC1::key_type;
-  static const KeyType src2_type = SRC2::key_type;
-  static const KeyType src3_type = SRC3::key_type;
-  const Instr* instr;
-  SRC1 src1;
-  SRC2 src2;
-  SRC3 src3;
-
- protected:
-  template <typename SEQ, typename T>
-  friend struct Sequence;
-  bool Load(const Instr* i) {
-    if (InstrKey(i).value == key && BASE::LoadDest(i)) {
-      instr = i;
-      src1.Load(i->src1);
-      src2.Load(i->src2);
-      src3.Load(i->src3);
-      return true;
-    }
-    return false;
-  }
-};
-
-template <typename T>
-const T GetTempReg(X64Emitter& e);
-template <>
-const Reg8 GetTempReg<Reg8>(X64Emitter& e) {
-  return e.al;
-}
-template <>
-const Reg16 GetTempReg<Reg16>(X64Emitter& e) {
-  return e.ax;
-}
-template <>
-const Reg32 GetTempReg<Reg32>(X64Emitter& e) {
-  return e.eax;
-}
-template <>
-const Reg64 GetTempReg<Reg64>(X64Emitter& e) {
-  return e.rax;
-}
-
-template <typename SEQ, typename T>
-struct Sequence {
-  typedef T EmitArgType;
-
-  static constexpr uint32_t head_key() { return T::key; }
-
-  static bool Select(X64Emitter& e, const Instr* i) {
-    T args;
-    if (!args.Load(i)) {
-      return false;
-    }
-    SEQ::Emit(e, args);
-    return true;
-  }
-
-  template <typename REG_FN>
-  static void EmitUnaryOp(X64Emitter& e, const EmitArgType& i,
-                          const REG_FN& reg_fn) {
-    if (i.src1.is_constant) {
-      e.mov(i.dest, i.src1.constant());
-      reg_fn(e, i.dest);
-    } else {
-      if (i.dest != i.src1) {
-        e.mov(i.dest, i.src1);
-      }
-      reg_fn(e, i.dest);
-    }
-  }
-
-  template <typename REG_REG_FN, typename REG_CONST_FN>
-  static void EmitCommutativeBinaryOp(X64Emitter& e, const EmitArgType& i,
-                                      const REG_REG_FN& reg_reg_fn,
-                                      const REG_CONST_FN& reg_const_fn) {
-    if (i.src1.is_constant) {
-      if (i.src2.is_constant) {
-        // Both constants.
-        if (i.src1.ConstantFitsIn32Reg()) {
-          e.mov(i.dest, i.src2.constant());
-          reg_const_fn(e, i.dest, static_cast<int32_t>(i.src1.constant()));
-        } else if (i.src2.ConstantFitsIn32Reg()) {
-          e.mov(i.dest, i.src1.constant());
-          reg_const_fn(e, i.dest, static_cast<int32_t>(i.src2.constant()));
-        } else {
-          e.mov(i.dest, i.src1.constant());
-          auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
-          e.mov(temp, i.src2.constant());
-          reg_reg_fn(e, i.dest, temp);
-        }
-      } else {
-        // src1 constant.
-        if (i.dest == i.src2) {
-          if (i.src1.ConstantFitsIn32Reg()) {
-            reg_const_fn(e, i.dest, static_cast<int32_t>(i.src1.constant()));
-          } else {
-            auto temp = GetTempReg<typename decltype(i.src1)::reg_type>(e);
-            e.mov(temp, i.src1.constant());
-            reg_reg_fn(e, i.dest, temp);
-          }
-        } else {
-          e.mov(i.dest, i.src1.constant());
-          reg_reg_fn(e, i.dest, i.src2);
-        }
-      }
-    } else if (i.src2.is_constant) {
-      if (i.dest == i.src1) {
-        if (i.src2.ConstantFitsIn32Reg()) {
-          reg_const_fn(e, i.dest, static_cast<int32_t>(i.src2.constant()));
-        } else {
-          auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
-          e.mov(temp, i.src2.constant());
-          reg_reg_fn(e, i.dest, temp);
-        }
-      } else {
-        e.mov(i.dest, i.src2.constant());
-        reg_reg_fn(e, i.dest, i.src1);
-      }
-    } else {
-      if (i.dest == i.src1) {
-        reg_reg_fn(e, i.dest, i.src2);
-      } else if (i.dest == i.src2) {
-        reg_reg_fn(e, i.dest, i.src1);
-      } else {
-        e.mov(i.dest, i.src1);
-        reg_reg_fn(e, i.dest, i.src2);
-      }
-    }
-  }
-  template <typename REG_REG_FN, typename REG_CONST_FN>
-  static void EmitAssociativeBinaryOp(X64Emitter& e, const EmitArgType& i,
-                                      const REG_REG_FN& reg_reg_fn,
-                                      const REG_CONST_FN& reg_const_fn) {
-    if (i.src1.is_constant) {
-      assert_true(!i.src2.is_constant);
-      if (i.dest == i.src2) {
-        auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
-        e.mov(temp, i.src2);
-        e.mov(i.dest, i.src1.constant());
-        reg_reg_fn(e, i.dest, temp);
-      } else {
-        e.mov(i.dest, i.src1.constant());
-        reg_reg_fn(e, i.dest, i.src2);
-      }
-    } else if (i.src2.is_constant) {
-      if (i.dest == i.src1) {
-        if (i.src2.ConstantFitsIn32Reg()) {
-          reg_const_fn(e, i.dest, static_cast<int32_t>(i.src2.constant()));
-        } else {
-          auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
-          e.mov(temp, i.src2.constant());
-          reg_reg_fn(e, i.dest, temp);
-        }
-      } else {
-        e.mov(i.dest, i.src1);
-        if (i.src2.ConstantFitsIn32Reg()) {
-          reg_const_fn(e, i.dest, static_cast<int32_t>(i.src2.constant()));
-        } else {
-          auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
-          e.mov(temp, i.src2.constant());
-          reg_reg_fn(e, i.dest, temp);
-        }
-      }
-    } else {
-      if (i.dest == i.src1) {
-        reg_reg_fn(e, i.dest, i.src2);
-      } else if (i.dest == i.src2) {
-        auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
-        e.mov(temp, i.src2);
-        e.mov(i.dest, i.src1);
-        reg_reg_fn(e, i.dest, temp);
-      } else {
-        e.mov(i.dest, i.src1);
-        reg_reg_fn(e, i.dest, i.src2);
-      }
-    }
-  }
-
-  template <typename FN>
-  static void EmitCommutativeBinaryXmmOp(X64Emitter& e, const EmitArgType& i,
-                                         const FN& fn) {
-    if (i.src1.is_constant) {
-      assert_true(!i.src2.is_constant);
-      e.LoadConstantXmm(e.xmm0, i.src1.constant());
-      fn(e, i.dest, e.xmm0, i.src2);
-    } else if (i.src2.is_constant) {
-      assert_true(!i.src1.is_constant);
-      e.LoadConstantXmm(e.xmm0, i.src2.constant());
-      fn(e, i.dest, i.src1, e.xmm0);
-    } else {
-      fn(e, i.dest, i.src1, i.src2);
-    }
-  }
-
-  template <typename FN>
-  static void EmitAssociativeBinaryXmmOp(X64Emitter& e, const EmitArgType& i,
-                                         const FN& fn) {
-    if (i.src1.is_constant) {
-      assert_true(!i.src2.is_constant);
-      e.LoadConstantXmm(e.xmm0, i.src1.constant());
-      fn(e, i.dest, e.xmm0, i.src2);
-    } else if (i.src2.is_constant) {
-      assert_true(!i.src1.is_constant);
-      e.LoadConstantXmm(e.xmm0, i.src2.constant());
-      fn(e, i.dest, i.src1, e.xmm0);
-    } else {
-      fn(e, i.dest, i.src1, i.src2);
-    }
-  }
-
-  template <typename REG_REG_FN, typename REG_CONST_FN>
-  static void EmitCommutativeCompareOp(X64Emitter& e, const EmitArgType& i,
-                                       const REG_REG_FN& reg_reg_fn,
-                                       const REG_CONST_FN& reg_const_fn) {
-    if (i.src1.is_constant) {
-      assert_true(!i.src2.is_constant);
-      if (i.src1.ConstantFitsIn32Reg()) {
-        reg_const_fn(e, i.src2, static_cast<int32_t>(i.src1.constant()));
-      } else {
-        auto temp = GetTempReg<typename decltype(i.src1)::reg_type>(e);
-        e.mov(temp, i.src1.constant());
-        reg_reg_fn(e, i.src2, temp);
-      }
-    } else if (i.src2.is_constant) {
-      assert_true(!i.src1.is_constant);
-      if (i.src2.ConstantFitsIn32Reg()) {
-        reg_const_fn(e, i.src1, static_cast<int32_t>(i.src2.constant()));
-      } else {
-        auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
-        e.mov(temp, i.src2.constant());
-        reg_reg_fn(e, i.src1, temp);
-      }
-    } else {
-      reg_reg_fn(e, i.src1, i.src2);
-    }
-  }
-  template <typename REG_REG_FN, typename REG_CONST_FN>
-  static void EmitAssociativeCompareOp(X64Emitter& e, const EmitArgType& i,
-                                       const REG_REG_FN& reg_reg_fn,
-                                       const REG_CONST_FN& reg_const_fn) {
-    if (i.src1.is_constant) {
-      assert_true(!i.src2.is_constant);
-      if (i.src1.ConstantFitsIn32Reg()) {
-        reg_const_fn(e, i.dest, i.src2, static_cast<int32_t>(i.src1.constant()),
-                     true);
-      } else {
-        auto temp = GetTempReg<typename decltype(i.src1)::reg_type>(e);
-        e.mov(temp, i.src1.constant());
-        reg_reg_fn(e, i.dest, i.src2, temp, true);
-      }
-    } else if (i.src2.is_constant) {
-      assert_true(!i.src1.is_constant);
-      if (i.src2.ConstantFitsIn32Reg()) {
-        reg_const_fn(e, i.dest, i.src1, static_cast<int32_t>(i.src2.constant()),
-                     false);
-      } else {
-        auto temp = GetTempReg<typename decltype(i.src2)::reg_type>(e);
-        e.mov(temp, i.src2.constant());
-        reg_reg_fn(e, i.dest, i.src1, temp, false);
-      }
-    } else {
-      reg_reg_fn(e, i.dest, i.src1, i.src2, false);
-    }
-  }
-};
-
-template <typename T>
-void Register() {
-  sequence_table.insert({T::head_key(), T::Select});
-}
-template <typename T, typename Tn, typename... Ts>
-void Register() {
-  Register<T>();
-  Register<Tn, Ts...>();
-}
-#define EMITTER_OPCODE_TABLE(name, ...) \
-  void Register_##name() { Register<__VA_ARGS__>(); }
-
 // ============================================================================
 // OPCODE_COMMENT
 // ============================================================================
@@ -702,532 +90,6 @@ struct SOURCE_OFFSET
 };
 EMITTER_OPCODE_TABLE(OPCODE_SOURCE_OFFSET, SOURCE_OFFSET);
 
-// ============================================================================
-// OPCODE_DEBUG_BREAK
-// ============================================================================
-struct DEBUG_BREAK : Sequence<DEBUG_BREAK, I<OPCODE_DEBUG_BREAK, VoidOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) { e.DebugBreak(); }
-};
-EMITTER_OPCODE_TABLE(OPCODE_DEBUG_BREAK, DEBUG_BREAK);
-
-// ============================================================================
-// OPCODE_DEBUG_BREAK_TRUE
-// ============================================================================
-struct DEBUG_BREAK_TRUE_I8
-    : Sequence<DEBUG_BREAK_TRUE_I8, I<OPCODE_DEBUG_BREAK_TRUE, VoidOp, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.DebugBreak();
-    e.L(skip);
-  }
-};
-struct DEBUG_BREAK_TRUE_I16
-    : Sequence<DEBUG_BREAK_TRUE_I16,
-               I<OPCODE_DEBUG_BREAK_TRUE, VoidOp, I16Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.DebugBreak();
-    e.L(skip);
-  }
-};
-struct DEBUG_BREAK_TRUE_I32
-    : Sequence<DEBUG_BREAK_TRUE_I32,
-               I<OPCODE_DEBUG_BREAK_TRUE, VoidOp, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.DebugBreak();
-    e.L(skip);
-  }
-};
-struct DEBUG_BREAK_TRUE_I64
-    : Sequence<DEBUG_BREAK_TRUE_I64,
-               I<OPCODE_DEBUG_BREAK_TRUE, VoidOp, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.DebugBreak();
-    e.L(skip);
-  }
-};
-struct DEBUG_BREAK_TRUE_F32
-    : Sequence<DEBUG_BREAK_TRUE_F32,
-               I<OPCODE_DEBUG_BREAK_TRUE, VoidOp, F32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vptest(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.DebugBreak();
-    e.L(skip);
-  }
-};
-struct DEBUG_BREAK_TRUE_F64
-    : Sequence<DEBUG_BREAK_TRUE_F64,
-               I<OPCODE_DEBUG_BREAK_TRUE, VoidOp, F64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vptest(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.DebugBreak();
-    e.L(skip);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_DEBUG_BREAK_TRUE, DEBUG_BREAK_TRUE_I8,
-                     DEBUG_BREAK_TRUE_I16, DEBUG_BREAK_TRUE_I32,
-                     DEBUG_BREAK_TRUE_I64, DEBUG_BREAK_TRUE_F32,
-                     DEBUG_BREAK_TRUE_F64);
-
-// ============================================================================
-// OPCODE_TRAP
-// ============================================================================
-struct TRAP : Sequence<TRAP, I<OPCODE_TRAP, VoidOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.Trap(i.instr->flags);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_TRAP, TRAP);
-
-// ============================================================================
-// OPCODE_TRAP_TRUE
-// ============================================================================
-struct TRAP_TRUE_I8
-    : Sequence<TRAP_TRUE_I8, I<OPCODE_TRAP_TRUE, VoidOp, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.Trap(i.instr->flags);
-    e.L(skip);
-  }
-};
-struct TRAP_TRUE_I16
-    : Sequence<TRAP_TRUE_I16, I<OPCODE_TRAP_TRUE, VoidOp, I16Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.Trap(i.instr->flags);
-    e.L(skip);
-  }
-};
-struct TRAP_TRUE_I32
-    : Sequence<TRAP_TRUE_I32, I<OPCODE_TRAP_TRUE, VoidOp, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.Trap(i.instr->flags);
-    e.L(skip);
-  }
-};
-struct TRAP_TRUE_I64
-    : Sequence<TRAP_TRUE_I64, I<OPCODE_TRAP_TRUE, VoidOp, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.Trap(i.instr->flags);
-    e.L(skip);
-  }
-};
-struct TRAP_TRUE_F32
-    : Sequence<TRAP_TRUE_F32, I<OPCODE_TRAP_TRUE, VoidOp, F32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vptest(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.Trap(i.instr->flags);
-    e.L(skip);
-  }
-};
-struct TRAP_TRUE_F64
-    : Sequence<TRAP_TRUE_F64, I<OPCODE_TRAP_TRUE, VoidOp, F64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vptest(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.Trap(i.instr->flags);
-    e.L(skip);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_TRAP_TRUE, TRAP_TRUE_I8, TRAP_TRUE_I16,
-                     TRAP_TRUE_I32, TRAP_TRUE_I64, TRAP_TRUE_F32,
-                     TRAP_TRUE_F64);
-
-// ============================================================================
-// OPCODE_CALL
-// ============================================================================
-struct CALL : Sequence<CALL, I<OPCODE_CALL, VoidOp, SymbolOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src1.value->is_guest());
-    e.Call(i.instr, static_cast<GuestFunction*>(i.src1.value));
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_CALL, CALL);
-
-// ============================================================================
-// OPCODE_CALL_TRUE
-// ============================================================================
-struct CALL_TRUE_I8
-    : Sequence<CALL_TRUE_I8, I<OPCODE_CALL_TRUE, VoidOp, I8Op, SymbolOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.value->is_guest());
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.Call(i.instr, static_cast<GuestFunction*>(i.src2.value));
-    e.L(skip);
-  }
-};
-struct CALL_TRUE_I16
-    : Sequence<CALL_TRUE_I16, I<OPCODE_CALL_TRUE, VoidOp, I16Op, SymbolOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.value->is_guest());
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.Call(i.instr, static_cast<GuestFunction*>(i.src2.value));
-    e.L(skip);
-  }
-};
-struct CALL_TRUE_I32
-    : Sequence<CALL_TRUE_I32, I<OPCODE_CALL_TRUE, VoidOp, I32Op, SymbolOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.value->is_guest());
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.Call(i.instr, static_cast<GuestFunction*>(i.src2.value));
-    e.L(skip);
-  }
-};
-struct CALL_TRUE_I64
-    : Sequence<CALL_TRUE_I64, I<OPCODE_CALL_TRUE, VoidOp, I64Op, SymbolOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.value->is_guest());
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.Call(i.instr, static_cast<GuestFunction*>(i.src2.value));
-    e.L(skip);
-  }
-};
-struct CALL_TRUE_F32
-    : Sequence<CALL_TRUE_F32, I<OPCODE_CALL_TRUE, VoidOp, F32Op, SymbolOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.value->is_guest());
-    e.vptest(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.Call(i.instr, static_cast<GuestFunction*>(i.src2.value));
-    e.L(skip);
-  }
-};
-struct CALL_TRUE_F64
-    : Sequence<CALL_TRUE_F64, I<OPCODE_CALL_TRUE, VoidOp, F64Op, SymbolOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.value->is_guest());
-    e.vptest(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip);
-    e.Call(i.instr, static_cast<GuestFunction*>(i.src2.value));
-    e.L(skip);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_CALL_TRUE, CALL_TRUE_I8, CALL_TRUE_I16,
-                     CALL_TRUE_I32, CALL_TRUE_I64, CALL_TRUE_F32,
-                     CALL_TRUE_F64);
-
-// ============================================================================
-// OPCODE_CALL_INDIRECT
-// ============================================================================
-struct CALL_INDIRECT
-    : Sequence<CALL_INDIRECT, I<OPCODE_CALL_INDIRECT, VoidOp, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.CallIndirect(i.instr, i.src1);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_CALL_INDIRECT, CALL_INDIRECT);
-
-// ============================================================================
-// OPCODE_CALL_INDIRECT_TRUE
-// ============================================================================
-struct CALL_INDIRECT_TRUE_I8
-    : Sequence<CALL_INDIRECT_TRUE_I8,
-               I<OPCODE_CALL_INDIRECT_TRUE, VoidOp, I8Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip, CodeGenerator::T_NEAR);
-    e.CallIndirect(i.instr, i.src2);
-    e.L(skip);
-  }
-};
-struct CALL_INDIRECT_TRUE_I16
-    : Sequence<CALL_INDIRECT_TRUE_I16,
-               I<OPCODE_CALL_INDIRECT_TRUE, VoidOp, I16Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip, CodeGenerator::T_NEAR);
-    e.CallIndirect(i.instr, i.src2);
-    e.L(skip);
-  }
-};
-struct CALL_INDIRECT_TRUE_I32
-    : Sequence<CALL_INDIRECT_TRUE_I32,
-               I<OPCODE_CALL_INDIRECT_TRUE, VoidOp, I32Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip, CodeGenerator::T_NEAR);
-    e.CallIndirect(i.instr, i.src2);
-    e.L(skip);
-  }
-};
-struct CALL_INDIRECT_TRUE_I64
-    : Sequence<CALL_INDIRECT_TRUE_I64,
-               I<OPCODE_CALL_INDIRECT_TRUE, VoidOp, I64Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip, CodeGenerator::T_NEAR);
-    e.CallIndirect(i.instr, i.src2);
-    e.L(skip);
-  }
-};
-struct CALL_INDIRECT_TRUE_F32
-    : Sequence<CALL_INDIRECT_TRUE_F32,
-               I<OPCODE_CALL_INDIRECT_TRUE, VoidOp, F32Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vptest(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip, CodeGenerator::T_NEAR);
-    e.CallIndirect(i.instr, i.src2);
-    e.L(skip);
-  }
-};
-struct CALL_INDIRECT_TRUE_F64
-    : Sequence<CALL_INDIRECT_TRUE_F64,
-               I<OPCODE_CALL_INDIRECT_TRUE, VoidOp, F64Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vptest(i.src1, i.src1);
-    Xbyak::Label skip;
-    e.jz(skip, CodeGenerator::T_NEAR);
-    e.CallIndirect(i.instr, i.src2);
-    e.L(skip);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_CALL_INDIRECT_TRUE, CALL_INDIRECT_TRUE_I8,
-                     CALL_INDIRECT_TRUE_I16, CALL_INDIRECT_TRUE_I32,
-                     CALL_INDIRECT_TRUE_I64, CALL_INDIRECT_TRUE_F32,
-                     CALL_INDIRECT_TRUE_F64);
-
-// ============================================================================
-// OPCODE_CALL_EXTERN
-// ============================================================================
-struct CALL_EXTERN
-    : Sequence<CALL_EXTERN, I<OPCODE_CALL_EXTERN, VoidOp, SymbolOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.CallExtern(i.instr, i.src1.value);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_CALL_EXTERN, CALL_EXTERN);
-
-// ============================================================================
-// OPCODE_RETURN
-// ============================================================================
-struct RETURN : Sequence<RETURN, I<OPCODE_RETURN, VoidOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    // If this is the last instruction in the last block, just let us
-    // fall through.
-    if (i.instr->next || i.instr->block->next) {
-      e.jmp(e.epilog_label(), CodeGenerator::T_NEAR);
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_RETURN, RETURN);
-
-// ============================================================================
-// OPCODE_RETURN_TRUE
-// ============================================================================
-struct RETURN_TRUE_I8
-    : Sequence<RETURN_TRUE_I8, I<OPCODE_RETURN_TRUE, VoidOp, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    e.jnz(e.epilog_label(), CodeGenerator::T_NEAR);
-  }
-};
-struct RETURN_TRUE_I16
-    : Sequence<RETURN_TRUE_I16, I<OPCODE_RETURN_TRUE, VoidOp, I16Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    e.jnz(e.epilog_label(), CodeGenerator::T_NEAR);
-  }
-};
-struct RETURN_TRUE_I32
-    : Sequence<RETURN_TRUE_I32, I<OPCODE_RETURN_TRUE, VoidOp, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    e.jnz(e.epilog_label(), CodeGenerator::T_NEAR);
-  }
-};
-struct RETURN_TRUE_I64
-    : Sequence<RETURN_TRUE_I64, I<OPCODE_RETURN_TRUE, VoidOp, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    e.jnz(e.epilog_label(), CodeGenerator::T_NEAR);
-  }
-};
-struct RETURN_TRUE_F32
-    : Sequence<RETURN_TRUE_F32, I<OPCODE_RETURN_TRUE, VoidOp, F32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vptest(i.src1, i.src1);
-    e.jnz(e.epilog_label(), CodeGenerator::T_NEAR);
-  }
-};
-struct RETURN_TRUE_F64
-    : Sequence<RETURN_TRUE_F64, I<OPCODE_RETURN_TRUE, VoidOp, F64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vptest(i.src1, i.src1);
-    e.jnz(e.epilog_label(), CodeGenerator::T_NEAR);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_RETURN_TRUE, RETURN_TRUE_I8, RETURN_TRUE_I16,
-                     RETURN_TRUE_I32, RETURN_TRUE_I64, RETURN_TRUE_F32,
-                     RETURN_TRUE_F64);
-
-// ============================================================================
-// OPCODE_SET_RETURN_ADDRESS
-// ============================================================================
-struct SET_RETURN_ADDRESS
-    : Sequence<SET_RETURN_ADDRESS,
-               I<OPCODE_SET_RETURN_ADDRESS, VoidOp, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.SetReturnAddress(i.src1.constant());
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_SET_RETURN_ADDRESS, SET_RETURN_ADDRESS);
-
-// ============================================================================
-// OPCODE_BRANCH
-// ============================================================================
-struct BRANCH : Sequence<BRANCH, I<OPCODE_BRANCH, VoidOp, LabelOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.jmp(i.src1.value->name, e.T_NEAR);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_BRANCH, BRANCH);
-
-// ============================================================================
-// OPCODE_BRANCH_TRUE
-// ============================================================================
-struct BRANCH_TRUE_I8
-    : Sequence<BRANCH_TRUE_I8, I<OPCODE_BRANCH_TRUE, VoidOp, I8Op, LabelOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    e.jnz(i.src2.value->name, e.T_NEAR);
-  }
-};
-struct BRANCH_TRUE_I16
-    : Sequence<BRANCH_TRUE_I16, I<OPCODE_BRANCH_TRUE, VoidOp, I16Op, LabelOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    e.jnz(i.src2.value->name, e.T_NEAR);
-  }
-};
-struct BRANCH_TRUE_I32
-    : Sequence<BRANCH_TRUE_I32, I<OPCODE_BRANCH_TRUE, VoidOp, I32Op, LabelOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    e.jnz(i.src2.value->name, e.T_NEAR);
-  }
-};
-struct BRANCH_TRUE_I64
-    : Sequence<BRANCH_TRUE_I64, I<OPCODE_BRANCH_TRUE, VoidOp, I64Op, LabelOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    e.jnz(i.src2.value->name, e.T_NEAR);
-  }
-};
-struct BRANCH_TRUE_F32
-    : Sequence<BRANCH_TRUE_F32, I<OPCODE_BRANCH_TRUE, VoidOp, F32Op, LabelOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vptest(i.src1, i.src1);
-    e.jnz(i.src2.value->name, e.T_NEAR);
-  }
-};
-struct BRANCH_TRUE_F64
-    : Sequence<BRANCH_TRUE_F64, I<OPCODE_BRANCH_TRUE, VoidOp, F64Op, LabelOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vptest(i.src1, i.src1);
-    e.jnz(i.src2.value->name, e.T_NEAR);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_BRANCH_TRUE, BRANCH_TRUE_I8, BRANCH_TRUE_I16,
-                     BRANCH_TRUE_I32, BRANCH_TRUE_I64, BRANCH_TRUE_F32,
-                     BRANCH_TRUE_F64);
-
-// ============================================================================
-// OPCODE_BRANCH_FALSE
-// ============================================================================
-struct BRANCH_FALSE_I8
-    : Sequence<BRANCH_FALSE_I8, I<OPCODE_BRANCH_FALSE, VoidOp, I8Op, LabelOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    e.jz(i.src2.value->name, e.T_NEAR);
-  }
-};
-struct BRANCH_FALSE_I16
-    : Sequence<BRANCH_FALSE_I16,
-               I<OPCODE_BRANCH_FALSE, VoidOp, I16Op, LabelOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    e.jz(i.src2.value->name, e.T_NEAR);
-  }
-};
-struct BRANCH_FALSE_I32
-    : Sequence<BRANCH_FALSE_I32,
-               I<OPCODE_BRANCH_FALSE, VoidOp, I32Op, LabelOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    e.jz(i.src2.value->name, e.T_NEAR);
-  }
-};
-struct BRANCH_FALSE_I64
-    : Sequence<BRANCH_FALSE_I64,
-               I<OPCODE_BRANCH_FALSE, VoidOp, I64Op, LabelOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.test(i.src1, i.src1);
-    e.jz(i.src2.value->name, e.T_NEAR);
-  }
-};
-struct BRANCH_FALSE_F32
-    : Sequence<BRANCH_FALSE_F32,
-               I<OPCODE_BRANCH_FALSE, VoidOp, F32Op, LabelOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vptest(i.src1, i.src1);
-    e.jz(i.src2.value->name, e.T_NEAR);
-  }
-};
-struct BRANCH_FALSE_F64
-    : Sequence<BRANCH_FALSE_F64,
-               I<OPCODE_BRANCH_FALSE, VoidOp, F64Op, LabelOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vptest(i.src1, i.src1);
-    e.jz(i.src2.value->name, e.T_NEAR);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_BRANCH_FALSE, BRANCH_FALSE_I8, BRANCH_FALSE_I16,
-                     BRANCH_FALSE_I32, BRANCH_FALSE_I64, BRANCH_FALSE_F32,
-                     BRANCH_FALSE_F64);
-
 // ============================================================================
 // OPCODE_ASSIGN
 // ============================================================================
@@ -1573,169 +435,6 @@ struct ROUND_V128 : Sequence<ROUND_V128, I<OPCODE_ROUND, V128Op, V128Op>> {
 };
 EMITTER_OPCODE_TABLE(OPCODE_ROUND, ROUND_F32, ROUND_F64, ROUND_V128);
 
-// ============================================================================
-// OPCODE_VECTOR_CONVERT_I2F
-// ============================================================================
-struct VECTOR_CONVERT_I2F
-    : Sequence<VECTOR_CONVERT_I2F,
-               I<OPCODE_VECTOR_CONVERT_I2F, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    // flags = ARITHMETIC_UNSIGNED
-    if (i.instr->flags & ARITHMETIC_UNSIGNED) {
-      // xmm0 = mask of positive values
-      e.vpcmpgtd(e.xmm0, i.src1, e.GetXmmConstPtr(XMMFFFF));
-
-      // scale any values >= (unsigned)INT_MIN back to [0, INT_MAX]
-      e.vpsubd(e.xmm1, i.src1, e.GetXmmConstPtr(XMMSignMaskI32));
-      e.vblendvps(e.xmm1, e.xmm1, i.src1, e.xmm0);
-
-      // xmm1 = [0, INT_MAX]
-      e.vcvtdq2ps(i.dest, e.xmm1);
-
-      // scale values back above [INT_MIN, UINT_MAX]
-      e.vpandn(e.xmm0, e.xmm0, e.GetXmmConstPtr(XMMPosIntMinPS));
-      e.vaddps(i.dest, i.dest, e.xmm0);
-    } else {
-      e.vcvtdq2ps(i.dest, i.src1);
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_CONVERT_I2F, VECTOR_CONVERT_I2F);
-
-// ============================================================================
-// OPCODE_VECTOR_CONVERT_F2I
-// ============================================================================
-struct VECTOR_CONVERT_F2I
-    : Sequence<VECTOR_CONVERT_F2I,
-               I<OPCODE_VECTOR_CONVERT_F2I, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    if (i.instr->flags & ARITHMETIC_UNSIGNED) {
-      // clamp to min 0
-      e.vmaxps(e.xmm0, i.src1, e.GetXmmConstPtr(XMMZero));
-
-      // xmm1 = mask of values >= (unsigned)INT_MIN
-      e.vcmpgeps(e.xmm1, e.xmm0, e.GetXmmConstPtr(XMMPosIntMinPS));
-
-      // scale any values >= (unsigned)INT_MIN back to [0, ...]
-      e.vsubps(e.xmm2, e.xmm0, e.GetXmmConstPtr(XMMPosIntMinPS));
-      e.vblendvps(e.xmm0, e.xmm0, e.xmm2, e.xmm1);
-
-      // xmm0 = [0, INT_MAX]
-      // this may still contain values > INT_MAX (if src has vals > UINT_MAX)
-      e.vcvttps2dq(i.dest, e.xmm0);
-
-      // xmm0 = mask of values that need saturation
-      e.vpcmpeqd(e.xmm0, i.dest, e.GetXmmConstPtr(XMMIntMin));
-
-      // scale values back above [INT_MIN, UINT_MAX]
-      e.vpand(e.xmm1, e.xmm1, e.GetXmmConstPtr(XMMIntMin));
-      e.vpaddd(i.dest, i.dest, e.xmm1);
-
-      // saturate values > UINT_MAX
-      e.vpor(i.dest, i.dest, e.xmm0);
-    } else {
-      // xmm2 = NaN mask
-      e.vcmpunordps(e.xmm2, i.src1, i.src1);
-
-      // convert packed floats to packed dwords
-      e.vcvttps2dq(e.xmm0, i.src1);
-
-      // (high bit) xmm1 = dest is indeterminate and i.src1 >= 0
-      e.vpcmpeqd(e.xmm1, e.xmm0, e.GetXmmConstPtr(XMMIntMin));
-      e.vpandn(e.xmm1, i.src1, e.xmm1);
-
-      // saturate positive values
-      e.vblendvps(i.dest, e.xmm0, e.GetXmmConstPtr(XMMIntMax), e.xmm1);
-
-      // mask NaNs
-      e.vpandn(i.dest, e.xmm2, i.dest);
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_CONVERT_F2I, VECTOR_CONVERT_F2I);
-
-// ============================================================================
-// OPCODE_LOAD_VECTOR_SHL
-// ============================================================================
-static const vec128_t lvsl_table[16] = {
-    vec128b(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15),
-    vec128b(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
-    vec128b(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17),
-    vec128b(3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18),
-    vec128b(4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19),
-    vec128b(5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20),
-    vec128b(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21),
-    vec128b(7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22),
-    vec128b(8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23),
-    vec128b(9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24),
-    vec128b(10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25),
-    vec128b(11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26),
-    vec128b(12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27),
-    vec128b(13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28),
-    vec128b(14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29),
-    vec128b(15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30),
-};
-struct LOAD_VECTOR_SHL_I8
-    : Sequence<LOAD_VECTOR_SHL_I8, I<OPCODE_LOAD_VECTOR_SHL, V128Op, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    if (i.src1.is_constant) {
-      auto sh = i.src1.constant();
-      assert_true(sh < xe::countof(lvsl_table));
-      e.mov(e.rax, (uintptr_t)&lvsl_table[sh]);
-      e.vmovaps(i.dest, e.ptr[e.rax]);
-    } else {
-      // TODO(benvanik): find a cheaper way of doing this.
-      e.movzx(e.rdx, i.src1);
-      e.and_(e.dx, 0xF);
-      e.shl(e.dx, 4);
-      e.mov(e.rax, (uintptr_t)lvsl_table);
-      e.vmovaps(i.dest, e.ptr[e.rax + e.rdx]);
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_LOAD_VECTOR_SHL, LOAD_VECTOR_SHL_I8);
-
-// ============================================================================
-// OPCODE_LOAD_VECTOR_SHR
-// ============================================================================
-static const vec128_t lvsr_table[16] = {
-    vec128b(16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31),
-    vec128b(15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30),
-    vec128b(14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29),
-    vec128b(13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28),
-    vec128b(12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27),
-    vec128b(11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26),
-    vec128b(10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25),
-    vec128b(9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24),
-    vec128b(8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23),
-    vec128b(7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22),
-    vec128b(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21),
-    vec128b(5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20),
-    vec128b(4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19),
-    vec128b(3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18),
-    vec128b(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17),
-    vec128b(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
-};
-struct LOAD_VECTOR_SHR_I8
-    : Sequence<LOAD_VECTOR_SHR_I8, I<OPCODE_LOAD_VECTOR_SHR, V128Op, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    if (i.src1.is_constant) {
-      auto sh = i.src1.constant();
-      assert_true(sh < xe::countof(lvsr_table));
-      e.mov(e.rax, (uintptr_t)&lvsr_table[sh]);
-      e.vmovaps(i.dest, e.ptr[e.rax]);
-    } else {
-      // TODO(benvanik): find a cheaper way of doing this.
-      e.movzx(e.rdx, i.src1);
-      e.and_(e.dx, 0xF);
-      e.shl(e.dx, 4);
-      e.mov(e.rax, (uintptr_t)lvsr_table);
-      e.vmovaps(i.dest, e.ptr[e.rax + e.rdx]);
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_LOAD_VECTOR_SHR, LOAD_VECTOR_SHR_I8);
-
 // ============================================================================
 // OPCODE_LOAD_CLOCK
 // ============================================================================
@@ -1751,343 +450,6 @@ struct LOAD_CLOCK : Sequence<LOAD_CLOCK, I<OPCODE_LOAD_CLOCK, I64Op>> {
 };
 EMITTER_OPCODE_TABLE(OPCODE_LOAD_CLOCK, LOAD_CLOCK);
 
-// ============================================================================
-// OPCODE_LOAD_LOCAL
-// ============================================================================
-// Note: all types are always aligned on the stack.
-struct LOAD_LOCAL_I8
-    : Sequence<LOAD_LOCAL_I8, I<OPCODE_LOAD_LOCAL, I8Op, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.mov(i.dest, e.byte[e.rsp + i.src1.constant()]);
-    // e.TraceLoadI8(DATA_LOCAL, i.src1.constant, i.dest);
-  }
-};
-struct LOAD_LOCAL_I16
-    : Sequence<LOAD_LOCAL_I16, I<OPCODE_LOAD_LOCAL, I16Op, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.mov(i.dest, e.word[e.rsp + i.src1.constant()]);
-    // e.TraceLoadI16(DATA_LOCAL, i.src1.constant, i.dest);
-  }
-};
-struct LOAD_LOCAL_I32
-    : Sequence<LOAD_LOCAL_I32, I<OPCODE_LOAD_LOCAL, I32Op, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.mov(i.dest, e.dword[e.rsp + i.src1.constant()]);
-    // e.TraceLoadI32(DATA_LOCAL, i.src1.constant, i.dest);
-  }
-};
-struct LOAD_LOCAL_I64
-    : Sequence<LOAD_LOCAL_I64, I<OPCODE_LOAD_LOCAL, I64Op, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.mov(i.dest, e.qword[e.rsp + i.src1.constant()]);
-    // e.TraceLoadI64(DATA_LOCAL, i.src1.constant, i.dest);
-  }
-};
-struct LOAD_LOCAL_F32
-    : Sequence<LOAD_LOCAL_F32, I<OPCODE_LOAD_LOCAL, F32Op, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vmovss(i.dest, e.dword[e.rsp + i.src1.constant()]);
-    // e.TraceLoadF32(DATA_LOCAL, i.src1.constant, i.dest);
-  }
-};
-struct LOAD_LOCAL_F64
-    : Sequence<LOAD_LOCAL_F64, I<OPCODE_LOAD_LOCAL, F64Op, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vmovsd(i.dest, e.qword[e.rsp + i.src1.constant()]);
-    // e.TraceLoadF64(DATA_LOCAL, i.src1.constant, i.dest);
-  }
-};
-struct LOAD_LOCAL_V128
-    : Sequence<LOAD_LOCAL_V128, I<OPCODE_LOAD_LOCAL, V128Op, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.vmovaps(i.dest, e.ptr[e.rsp + i.src1.constant()]);
-    // e.TraceLoadV128(DATA_LOCAL, i.src1.constant, i.dest);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_LOAD_LOCAL, LOAD_LOCAL_I8, LOAD_LOCAL_I16,
-                     LOAD_LOCAL_I32, LOAD_LOCAL_I64, LOAD_LOCAL_F32,
-                     LOAD_LOCAL_F64, LOAD_LOCAL_V128);
-
-// ============================================================================
-// OPCODE_STORE_LOCAL
-// ============================================================================
-// Note: all types are always aligned on the stack.
-struct STORE_LOCAL_I8
-    : Sequence<STORE_LOCAL_I8, I<OPCODE_STORE_LOCAL, VoidOp, I32Op, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    // e.TraceStoreI8(DATA_LOCAL, i.src1.constant, i.src2);
-    e.mov(e.byte[e.rsp + i.src1.constant()], i.src2);
-  }
-};
-struct STORE_LOCAL_I16
-    : Sequence<STORE_LOCAL_I16, I<OPCODE_STORE_LOCAL, VoidOp, I32Op, I16Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    // e.TraceStoreI16(DATA_LOCAL, i.src1.constant, i.src2);
-    e.mov(e.word[e.rsp + i.src1.constant()], i.src2);
-  }
-};
-struct STORE_LOCAL_I32
-    : Sequence<STORE_LOCAL_I32, I<OPCODE_STORE_LOCAL, VoidOp, I32Op, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    // e.TraceStoreI32(DATA_LOCAL, i.src1.constant, i.src2);
-    e.mov(e.dword[e.rsp + i.src1.constant()], i.src2);
-  }
-};
-struct STORE_LOCAL_I64
-    : Sequence<STORE_LOCAL_I64, I<OPCODE_STORE_LOCAL, VoidOp, I32Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    // e.TraceStoreI64(DATA_LOCAL, i.src1.constant, i.src2);
-    e.mov(e.qword[e.rsp + i.src1.constant()], i.src2);
-  }
-};
-struct STORE_LOCAL_F32
-    : Sequence<STORE_LOCAL_F32, I<OPCODE_STORE_LOCAL, VoidOp, I32Op, F32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    // e.TraceStoreF32(DATA_LOCAL, i.src1.constant, i.src2);
-    e.vmovss(e.dword[e.rsp + i.src1.constant()], i.src2);
-  }
-};
-struct STORE_LOCAL_F64
-    : Sequence<STORE_LOCAL_F64, I<OPCODE_STORE_LOCAL, VoidOp, I32Op, F64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    // e.TraceStoreF64(DATA_LOCAL, i.src1.constant, i.src2);
-    e.vmovsd(e.qword[e.rsp + i.src1.constant()], i.src2);
-  }
-};
-struct STORE_LOCAL_V128
-    : Sequence<STORE_LOCAL_V128, I<OPCODE_STORE_LOCAL, VoidOp, I32Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    // e.TraceStoreV128(DATA_LOCAL, i.src1.constant, i.src2);
-    e.vmovaps(e.ptr[e.rsp + i.src1.constant()], i.src2);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_STORE_LOCAL, STORE_LOCAL_I8, STORE_LOCAL_I16,
-                     STORE_LOCAL_I32, STORE_LOCAL_I64, STORE_LOCAL_F32,
-                     STORE_LOCAL_F64, STORE_LOCAL_V128);
-
-// ============================================================================
-// OPCODE_LOAD_CONTEXT
-// ============================================================================
-// Note: all types are always aligned in the context.
-RegExp ComputeContextAddress(X64Emitter& e, const OffsetOp& offset) {
-  return e.GetContextReg() + offset.value;
-}
-struct LOAD_CONTEXT_I8
-    : Sequence<LOAD_CONTEXT_I8, I<OPCODE_LOAD_CONTEXT, I8Op, OffsetOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeContextAddress(e, i.src1);
-    e.mov(i.dest, e.byte[addr]);
-    if (IsTracingData()) {
-      e.mov(e.r8, e.byte[addr]);
-      e.mov(e.rdx, i.src1.value);
-      e.CallNative(reinterpret_cast<void*>(TraceContextLoadI8));
-    }
-  }
-};
-struct LOAD_CONTEXT_I16
-    : Sequence<LOAD_CONTEXT_I16, I<OPCODE_LOAD_CONTEXT, I16Op, OffsetOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeContextAddress(e, i.src1);
-    e.mov(i.dest, e.word[addr]);
-    if (IsTracingData()) {
-      e.mov(e.r8, e.word[addr]);
-      e.mov(e.rdx, i.src1.value);
-      e.CallNative(reinterpret_cast<void*>(TraceContextLoadI16));
-    }
-  }
-};
-struct LOAD_CONTEXT_I32
-    : Sequence<LOAD_CONTEXT_I32, I<OPCODE_LOAD_CONTEXT, I32Op, OffsetOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeContextAddress(e, i.src1);
-    e.mov(i.dest, e.dword[addr]);
-    if (IsTracingData()) {
-      e.mov(e.r8, e.dword[addr]);
-      e.mov(e.rdx, i.src1.value);
-      e.CallNative(reinterpret_cast<void*>(TraceContextLoadI32));
-    }
-  }
-};
-struct LOAD_CONTEXT_I64
-    : Sequence<LOAD_CONTEXT_I64, I<OPCODE_LOAD_CONTEXT, I64Op, OffsetOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeContextAddress(e, i.src1);
-    e.mov(i.dest, e.qword[addr]);
-    if (IsTracingData()) {
-      e.mov(e.r8, e.qword[addr]);
-      e.mov(e.rdx, i.src1.value);
-      e.CallNative(reinterpret_cast<void*>(TraceContextLoadI64));
-    }
-  }
-};
-struct LOAD_CONTEXT_F32
-    : Sequence<LOAD_CONTEXT_F32, I<OPCODE_LOAD_CONTEXT, F32Op, OffsetOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeContextAddress(e, i.src1);
-    e.vmovss(i.dest, e.dword[addr]);
-    if (IsTracingData()) {
-      e.lea(e.r8, e.dword[addr]);
-      e.mov(e.rdx, i.src1.value);
-      e.CallNative(reinterpret_cast<void*>(TraceContextLoadF32));
-    }
-  }
-};
-struct LOAD_CONTEXT_F64
-    : Sequence<LOAD_CONTEXT_F64, I<OPCODE_LOAD_CONTEXT, F64Op, OffsetOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeContextAddress(e, i.src1);
-    e.vmovsd(i.dest, e.qword[addr]);
-    if (IsTracingData()) {
-      e.lea(e.r8, e.qword[addr]);
-      e.mov(e.rdx, i.src1.value);
-      e.CallNative(reinterpret_cast<void*>(TraceContextLoadF64));
-    }
-  }
-};
-struct LOAD_CONTEXT_V128
-    : Sequence<LOAD_CONTEXT_V128, I<OPCODE_LOAD_CONTEXT, V128Op, OffsetOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeContextAddress(e, i.src1);
-    e.vmovaps(i.dest, e.ptr[addr]);
-    if (IsTracingData()) {
-      e.lea(e.r8, e.ptr[addr]);
-      e.mov(e.rdx, i.src1.value);
-      e.CallNative(reinterpret_cast<void*>(TraceContextLoadV128));
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_LOAD_CONTEXT, LOAD_CONTEXT_I8, LOAD_CONTEXT_I16,
-                     LOAD_CONTEXT_I32, LOAD_CONTEXT_I64, LOAD_CONTEXT_F32,
-                     LOAD_CONTEXT_F64, LOAD_CONTEXT_V128);
-
-// ============================================================================
-// OPCODE_STORE_CONTEXT
-// ============================================================================
-// Note: all types are always aligned on the stack.
-struct STORE_CONTEXT_I8
-    : Sequence<STORE_CONTEXT_I8,
-               I<OPCODE_STORE_CONTEXT, VoidOp, OffsetOp, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeContextAddress(e, i.src1);
-    if (i.src2.is_constant) {
-      e.mov(e.byte[addr], i.src2.constant());
-    } else {
-      e.mov(e.byte[addr], i.src2);
-    }
-    if (IsTracingData()) {
-      e.mov(e.r8, e.byte[addr]);
-      e.mov(e.rdx, i.src1.value);
-      e.CallNative(reinterpret_cast<void*>(TraceContextStoreI8));
-    }
-  }
-};
-struct STORE_CONTEXT_I16
-    : Sequence<STORE_CONTEXT_I16,
-               I<OPCODE_STORE_CONTEXT, VoidOp, OffsetOp, I16Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeContextAddress(e, i.src1);
-    if (i.src2.is_constant) {
-      e.mov(e.word[addr], i.src2.constant());
-    } else {
-      e.mov(e.word[addr], i.src2);
-    }
-    if (IsTracingData()) {
-      e.mov(e.r8, e.word[addr]);
-      e.mov(e.rdx, i.src1.value);
-      e.CallNative(reinterpret_cast<void*>(TraceContextStoreI16));
-    }
-  }
-};
-struct STORE_CONTEXT_I32
-    : Sequence<STORE_CONTEXT_I32,
-               I<OPCODE_STORE_CONTEXT, VoidOp, OffsetOp, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeContextAddress(e, i.src1);
-    if (i.src2.is_constant) {
-      e.mov(e.dword[addr], i.src2.constant());
-    } else {
-      e.mov(e.dword[addr], i.src2);
-    }
-    if (IsTracingData()) {
-      e.mov(e.r8, e.dword[addr]);
-      e.mov(e.rdx, i.src1.value);
-      e.CallNative(reinterpret_cast<void*>(TraceContextStoreI32));
-    }
-  }
-};
-struct STORE_CONTEXT_I64
-    : Sequence<STORE_CONTEXT_I64,
-               I<OPCODE_STORE_CONTEXT, VoidOp, OffsetOp, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeContextAddress(e, i.src1);
-    if (i.src2.is_constant) {
-      e.MovMem64(addr, i.src2.constant());
-    } else {
-      e.mov(e.qword[addr], i.src2);
-    }
-    if (IsTracingData()) {
-      e.mov(e.r8, e.qword[addr]);
-      e.mov(e.rdx, i.src1.value);
-      e.CallNative(reinterpret_cast<void*>(TraceContextStoreI64));
-    }
-  }
-};
-struct STORE_CONTEXT_F32
-    : Sequence<STORE_CONTEXT_F32,
-               I<OPCODE_STORE_CONTEXT, VoidOp, OffsetOp, F32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeContextAddress(e, i.src1);
-    if (i.src2.is_constant) {
-      e.mov(e.dword[addr], i.src2.value->constant.i32);
-    } else {
-      e.vmovss(e.dword[addr], i.src2);
-    }
-    if (IsTracingData()) {
-      e.lea(e.r8, e.dword[addr]);
-      e.mov(e.rdx, i.src1.value);
-      e.CallNative(reinterpret_cast<void*>(TraceContextStoreF32));
-    }
-  }
-};
-struct STORE_CONTEXT_F64
-    : Sequence<STORE_CONTEXT_F64,
-               I<OPCODE_STORE_CONTEXT, VoidOp, OffsetOp, F64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeContextAddress(e, i.src1);
-    if (i.src2.is_constant) {
-      e.MovMem64(addr, i.src2.value->constant.i64);
-    } else {
-      e.vmovsd(e.qword[addr], i.src2);
-    }
-    if (IsTracingData()) {
-      e.lea(e.r8, e.qword[addr]);
-      e.mov(e.rdx, i.src1.value);
-      e.CallNative(reinterpret_cast<void*>(TraceContextStoreF64));
-    }
-  }
-};
-struct STORE_CONTEXT_V128
-    : Sequence<STORE_CONTEXT_V128,
-               I<OPCODE_STORE_CONTEXT, VoidOp, OffsetOp, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeContextAddress(e, i.src1);
-    if (i.src2.is_constant) {
-      e.LoadConstantXmm(e.xmm0, i.src2.constant());
-      e.vmovaps(e.ptr[addr], e.xmm0);
-    } else {
-      e.vmovaps(e.ptr[addr], i.src2);
-    }
-    if (IsTracingData()) {
-      e.lea(e.r8, e.ptr[addr]);
-      e.mov(e.rdx, i.src1.value);
-      e.CallNative(reinterpret_cast<void*>(TraceContextStoreV128));
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_STORE_CONTEXT, STORE_CONTEXT_I8, STORE_CONTEXT_I16,
-                     STORE_CONTEXT_I32, STORE_CONTEXT_I64, STORE_CONTEXT_F32,
-                     STORE_CONTEXT_F64, STORE_CONTEXT_V128);
-
 // ============================================================================
 // OPCODE_CONTEXT_BARRIER
 // ============================================================================
@@ -2097,601 +459,6 @@ struct CONTEXT_BARRIER
 };
 EMITTER_OPCODE_TABLE(OPCODE_CONTEXT_BARRIER, CONTEXT_BARRIER);
 
-// ============================================================================
-// OPCODE_LOAD_MMIO
-// ============================================================================
-// Note: all types are always aligned in the context.
-struct LOAD_MMIO_I32
-    : Sequence<LOAD_MMIO_I32, I<OPCODE_LOAD_MMIO, I32Op, OffsetOp, OffsetOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    // uint64_t (context, addr)
-    auto mmio_range = reinterpret_cast<MMIORange*>(i.src1.value);
-    auto read_address = uint32_t(i.src2.value);
-    e.mov(e.r8, uint64_t(mmio_range->callback_context));
-    e.mov(e.r9d, read_address);
-    e.CallNativeSafe(reinterpret_cast<void*>(mmio_range->read));
-    e.bswap(e.eax);
-    e.mov(i.dest, e.eax);
-    if (IsTracingData()) {
-      e.mov(e.r8, i.dest);
-      e.mov(e.edx, read_address);
-      e.CallNative(reinterpret_cast<void*>(TraceContextLoadI32));
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_LOAD_MMIO, LOAD_MMIO_I32);
-
-// ============================================================================
-// OPCODE_STORE_MMIO
-// ============================================================================
-// Note: all types are always aligned on the stack.
-struct STORE_MMIO_I32
-    : Sequence<STORE_MMIO_I32,
-               I<OPCODE_STORE_MMIO, VoidOp, OffsetOp, OffsetOp, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    // void (context, addr, value)
-    auto mmio_range = reinterpret_cast<MMIORange*>(i.src1.value);
-    auto write_address = uint32_t(i.src2.value);
-    e.mov(e.r8, uint64_t(mmio_range->callback_context));
-    e.mov(e.r9d, write_address);
-    if (i.src3.is_constant) {
-      e.mov(e.r10d, xe::byte_swap(i.src3.constant()));
-    } else {
-      e.mov(e.r10d, i.src3);
-      e.bswap(e.r10d);
-    }
-    e.CallNativeSafe(reinterpret_cast<void*>(mmio_range->write));
-    if (IsTracingData()) {
-      if (i.src3.is_constant) {
-        e.mov(e.r8d, i.src3.constant());
-      } else {
-        e.mov(e.r8d, i.src3);
-      }
-      e.mov(e.edx, write_address);
-      e.CallNative(reinterpret_cast<void*>(TraceContextStoreI32));
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_STORE_MMIO, STORE_MMIO_I32);
-
-// ============================================================================
-// OPCODE_LOAD_OFFSET
-// ============================================================================
-template <typename T>
-RegExp ComputeMemoryAddressOffset(X64Emitter& e, const T& guest,
-                                  const T& offset) {
-  int32_t offset_const = static_cast<int32_t>(offset.constant());
-
-  if (guest.is_constant) {
-    uint32_t address = static_cast<uint32_t>(guest.constant());
-    address += static_cast<int32_t>(offset.constant());
-    if (address < 0x80000000) {
-      return e.GetMembaseReg() + address;
-    } else {
-      e.mov(e.eax, address);
-      return e.GetMembaseReg() + e.rax;
-    }
-  } else {
-    // Clear the top 32 bits, as they are likely garbage.
-    // TODO(benvanik): find a way to avoid doing this.
-    e.mov(e.eax, guest.reg().cvt32());
-    return e.GetMembaseReg() + e.rax + offset_const;
-  }
-}
-
-struct LOAD_OFFSET_I8
-    : Sequence<LOAD_OFFSET_I8, I<OPCODE_LOAD_OFFSET, I8Op, I64Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
-    e.mov(i.dest, e.byte[addr]);
-  }
-};
-
-struct LOAD_OFFSET_I16
-    : Sequence<LOAD_OFFSET_I16, I<OPCODE_LOAD_OFFSET, I16Op, I64Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
-        e.movbe(i.dest, e.word[addr]);
-      } else {
-        e.mov(i.dest, e.word[addr]);
-        e.ror(i.dest, 8);
-      }
-    } else {
-      e.mov(i.dest, e.word[addr]);
-    }
-  }
-};
-
-struct LOAD_OFFSET_I32
-    : Sequence<LOAD_OFFSET_I32, I<OPCODE_LOAD_OFFSET, I32Op, I64Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
-        e.movbe(i.dest, e.dword[addr]);
-      } else {
-        e.mov(i.dest, e.dword[addr]);
-        e.bswap(i.dest);
-      }
-    } else {
-      e.mov(i.dest, e.dword[addr]);
-    }
-  }
-};
-
-struct LOAD_OFFSET_I64
-    : Sequence<LOAD_OFFSET_I64, I<OPCODE_LOAD_OFFSET, I64Op, I64Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
-        e.movbe(i.dest, e.qword[addr]);
-      } else {
-        e.mov(i.dest, e.qword[addr]);
-        e.bswap(i.dest);
-      }
-    } else {
-      e.mov(i.dest, e.qword[addr]);
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_LOAD_OFFSET, LOAD_OFFSET_I8, LOAD_OFFSET_I16,
-                     LOAD_OFFSET_I32, LOAD_OFFSET_I64);
-
-// ============================================================================
-// OPCODE_STORE_OFFSET
-// ============================================================================
-struct STORE_OFFSET_I8
-    : Sequence<STORE_OFFSET_I8,
-               I<OPCODE_STORE_OFFSET, VoidOp, I64Op, I64Op, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
-    if (i.src3.is_constant) {
-      e.mov(e.byte[addr], i.src3.constant());
-    } else {
-      e.mov(e.byte[addr], i.src3);
-    }
-  }
-};
-
-struct STORE_OFFSET_I16
-    : Sequence<STORE_OFFSET_I16,
-               I<OPCODE_STORE_OFFSET, VoidOp, I64Op, I64Op, I16Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      assert_false(i.src3.is_constant);
-      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
-        e.movbe(e.word[addr], i.src3);
-      } else {
-        assert_always("not implemented");
-      }
-    } else {
-      if (i.src3.is_constant) {
-        e.mov(e.word[addr], i.src3.constant());
-      } else {
-        e.mov(e.word[addr], i.src3);
-      }
-    }
-  }
-};
-
-struct STORE_OFFSET_I32
-    : Sequence<STORE_OFFSET_I32,
-               I<OPCODE_STORE_OFFSET, VoidOp, I64Op, I64Op, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      assert_false(i.src3.is_constant);
-      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
-        e.movbe(e.dword[addr], i.src3);
-      } else {
-        assert_always("not implemented");
-      }
-    } else {
-      if (i.src3.is_constant) {
-        e.mov(e.dword[addr], i.src3.constant());
-      } else {
-        e.mov(e.dword[addr], i.src3);
-      }
-    }
-  }
-};
-
-struct STORE_OFFSET_I64
-    : Sequence<STORE_OFFSET_I64,
-               I<OPCODE_STORE_OFFSET, VoidOp, I64Op, I64Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddressOffset(e, i.src1, i.src2);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      assert_false(i.src3.is_constant);
-      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
-        e.movbe(e.qword[addr], i.src3);
-      } else {
-        assert_always("not implemented");
-      }
-    } else {
-      if (i.src3.is_constant) {
-        e.MovMem64(addr, i.src3.constant());
-      } else {
-        e.mov(e.qword[addr], i.src3);
-      }
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_STORE_OFFSET, STORE_OFFSET_I8, STORE_OFFSET_I16,
-                     STORE_OFFSET_I32, STORE_OFFSET_I64);
-
-// ============================================================================
-// OPCODE_LOAD
-// ============================================================================
-// Note: most *should* be aligned, but needs to be checked!
-template <typename T>
-RegExp ComputeMemoryAddress(X64Emitter& e, const T& guest) {
-  if (guest.is_constant) {
-    // TODO(benvanik): figure out how to do this without a temp.
-    // Since the constant is often 0x8... if we tried to use that as a
-    // displacement it would be sign extended and mess things up.
-    uint32_t address = static_cast<uint32_t>(guest.constant());
-    if (address < 0x80000000) {
-      return e.GetMembaseReg() + address;
-    } else {
-      e.mov(e.eax, address);
-      return e.GetMembaseReg() + e.rax;
-    }
-  } else {
-    // Clear the top 32 bits, as they are likely garbage.
-    // TODO(benvanik): find a way to avoid doing this.
-    e.mov(e.eax, guest.reg().cvt32());
-    return e.GetMembaseReg() + e.rax;
-  }
-}
-struct LOAD_I8 : Sequence<LOAD_I8, I<OPCODE_LOAD, I8Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    e.mov(i.dest, e.byte[addr]);
-    if (IsTracingData()) {
-      e.mov(e.r8b, i.dest);
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemoryLoadI8));
-    }
-  }
-};
-struct LOAD_I16 : Sequence<LOAD_I16, I<OPCODE_LOAD, I16Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
-        e.movbe(i.dest, e.word[addr]);
-      } else {
-        e.mov(i.dest, e.word[addr]);
-        e.ror(i.dest, 8);
-      }
-    } else {
-      e.mov(i.dest, e.word[addr]);
-    }
-    if (IsTracingData()) {
-      e.mov(e.r8w, i.dest);
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemoryLoadI16));
-    }
-  }
-};
-struct LOAD_I32 : Sequence<LOAD_I32, I<OPCODE_LOAD, I32Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
-        e.movbe(i.dest, e.dword[addr]);
-      } else {
-        e.mov(i.dest, e.dword[addr]);
-        e.bswap(i.dest);
-      }
-    } else {
-      e.mov(i.dest, e.dword[addr]);
-    }
-    if (IsTracingData()) {
-      e.mov(e.r8d, i.dest);
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemoryLoadI32));
-    }
-  }
-};
-struct LOAD_I64 : Sequence<LOAD_I64, I<OPCODE_LOAD, I64Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
-        e.movbe(i.dest, e.qword[addr]);
-      } else {
-        e.mov(i.dest, e.qword[addr]);
-        e.bswap(i.dest);
-      }
-    } else {
-      e.mov(i.dest, e.qword[addr]);
-    }
-    if (IsTracingData()) {
-      e.mov(e.r8, i.dest);
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemoryLoadI64));
-    }
-  }
-};
-struct LOAD_F32 : Sequence<LOAD_F32, I<OPCODE_LOAD, F32Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    e.vmovss(i.dest, e.dword[addr]);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      assert_always("not implemented yet");
-    }
-    if (IsTracingData()) {
-      e.lea(e.r8, e.dword[addr]);
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemoryLoadF32));
-    }
-  }
-};
-struct LOAD_F64 : Sequence<LOAD_F64, I<OPCODE_LOAD, F64Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    e.vmovsd(i.dest, e.qword[addr]);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      assert_always("not implemented yet");
-    }
-    if (IsTracingData()) {
-      e.lea(e.r8, e.qword[addr]);
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemoryLoadF64));
-    }
-  }
-};
-struct LOAD_V128 : Sequence<LOAD_V128, I<OPCODE_LOAD, V128Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    // TODO(benvanik): we should try to stick to movaps if possible.
-    e.vmovups(i.dest, e.ptr[addr]);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      // TODO(benvanik): find a way to do this without the memory load.
-      e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMByteSwapMask));
-    }
-    if (IsTracingData()) {
-      e.lea(e.r8, e.ptr[addr]);
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemoryLoadV128));
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_LOAD, LOAD_I8, LOAD_I16, LOAD_I32, LOAD_I64,
-                     LOAD_F32, LOAD_F64, LOAD_V128);
-
-// ============================================================================
-// OPCODE_STORE
-// ============================================================================
-// Note: most *should* be aligned, but needs to be checked!
-struct STORE_I8 : Sequence<STORE_I8, I<OPCODE_STORE, VoidOp, I64Op, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    if (i.src2.is_constant) {
-      e.mov(e.byte[addr], i.src2.constant());
-    } else {
-      e.mov(e.byte[addr], i.src2);
-    }
-    if (IsTracingData()) {
-      addr = ComputeMemoryAddress(e, i.src1);
-      e.mov(e.r8b, e.byte[addr]);
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemoryStoreI8));
-    }
-  }
-};
-struct STORE_I16 : Sequence<STORE_I16, I<OPCODE_STORE, VoidOp, I64Op, I16Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      assert_false(i.src2.is_constant);
-      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
-        e.movbe(e.word[addr], i.src2);
-      } else {
-        assert_always("not implemented");
-      }
-    } else {
-      if (i.src2.is_constant) {
-        e.mov(e.word[addr], i.src2.constant());
-      } else {
-        e.mov(e.word[addr], i.src2);
-      }
-    }
-    if (IsTracingData()) {
-      addr = ComputeMemoryAddress(e, i.src1);
-      e.mov(e.r8w, e.word[addr]);
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemoryStoreI16));
-    }
-  }
-};
-struct STORE_I32 : Sequence<STORE_I32, I<OPCODE_STORE, VoidOp, I64Op, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      assert_false(i.src2.is_constant);
-      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
-        e.movbe(e.dword[addr], i.src2);
-      } else {
-        assert_always("not implemented");
-      }
-    } else {
-      if (i.src2.is_constant) {
-        e.mov(e.dword[addr], i.src2.constant());
-      } else {
-        e.mov(e.dword[addr], i.src2);
-      }
-    }
-    if (IsTracingData()) {
-      addr = ComputeMemoryAddress(e, i.src1);
-      e.mov(e.r8d, e.dword[addr]);
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemoryStoreI32));
-    }
-  }
-};
-struct STORE_I64 : Sequence<STORE_I64, I<OPCODE_STORE, VoidOp, I64Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      assert_false(i.src2.is_constant);
-      if (e.IsFeatureEnabled(kX64EmitMovbe)) {
-        e.movbe(e.qword[addr], i.src2);
-      } else {
-        assert_always("not implemented");
-      }
-    } else {
-      if (i.src2.is_constant) {
-        e.MovMem64(addr, i.src2.constant());
-      } else {
-        e.mov(e.qword[addr], i.src2);
-      }
-    }
-    if (IsTracingData()) {
-      addr = ComputeMemoryAddress(e, i.src1);
-      e.mov(e.r8, e.qword[addr]);
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemoryStoreI64));
-    }
-  }
-};
-struct STORE_F32 : Sequence<STORE_F32, I<OPCODE_STORE, VoidOp, I64Op, F32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      assert_false(i.src2.is_constant);
-      assert_always("not yet implemented");
-    } else {
-      if (i.src2.is_constant) {
-        e.mov(e.dword[addr], i.src2.value->constant.i32);
-      } else {
-        e.vmovss(e.dword[addr], i.src2);
-      }
-    }
-    if (IsTracingData()) {
-      addr = ComputeMemoryAddress(e, i.src1);
-      e.lea(e.r8, e.ptr[addr]);
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemoryStoreF32));
-    }
-  }
-};
-struct STORE_F64 : Sequence<STORE_F64, I<OPCODE_STORE, VoidOp, I64Op, F64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      assert_false(i.src2.is_constant);
-      assert_always("not yet implemented");
-    } else {
-      if (i.src2.is_constant) {
-        e.MovMem64(addr, i.src2.value->constant.i64);
-      } else {
-        e.vmovsd(e.qword[addr], i.src2);
-      }
-    }
-    if (IsTracingData()) {
-      addr = ComputeMemoryAddress(e, i.src1);
-      e.lea(e.r8, e.ptr[addr]);
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemoryStoreF64));
-    }
-  }
-};
-struct STORE_V128
-    : Sequence<STORE_V128, I<OPCODE_STORE, VoidOp, I64Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    if (i.instr->flags & LoadStoreFlags::LOAD_STORE_BYTE_SWAP) {
-      assert_false(i.src2.is_constant);
-      e.vpshufb(e.xmm0, i.src2, e.GetXmmConstPtr(XMMByteSwapMask));
-      e.vmovaps(e.ptr[addr], e.xmm0);
-    } else {
-      if (i.src2.is_constant) {
-        e.LoadConstantXmm(e.xmm0, i.src2.constant());
-        e.vmovaps(e.ptr[addr], e.xmm0);
-      } else {
-        e.vmovaps(e.ptr[addr], i.src2);
-      }
-    }
-    if (IsTracingData()) {
-      addr = ComputeMemoryAddress(e, i.src1);
-      e.lea(e.r8, e.ptr[addr]);
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemoryStoreV128));
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_STORE, STORE_I8, STORE_I16, STORE_I32, STORE_I64,
-                     STORE_F32, STORE_F64, STORE_V128);
-
-// ============================================================================
-// OPCODE_PREFETCH
-// ============================================================================
-struct PREFETCH
-    : Sequence<PREFETCH, I<OPCODE_PREFETCH, VoidOp, I64Op, OffsetOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    // TODO(benvanik): prefetch addr -> length.
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_PREFETCH, PREFETCH);
-
-// ============================================================================
-// OPCODE_MEMORY_BARRIER
-// ============================================================================
-struct MEMORY_BARRIER
-    : Sequence<MEMORY_BARRIER, I<OPCODE_MEMORY_BARRIER, VoidOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) { e.mfence(); }
-};
-EMITTER_OPCODE_TABLE(OPCODE_MEMORY_BARRIER, MEMORY_BARRIER);
-
-// ============================================================================
-// OPCODE_MEMSET
-// ============================================================================
-struct MEMSET_I64_I8_I64
-    : Sequence<MEMSET_I64_I8_I64,
-               I<OPCODE_MEMSET, VoidOp, I64Op, I8Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.is_constant);
-    assert_true(i.src3.is_constant);
-    assert_true(i.src2.constant() == 0);
-    e.vpxor(e.xmm0, e.xmm0);
-    auto addr = ComputeMemoryAddress(e, i.src1);
-    switch (i.src3.constant()) {
-      case 32:
-        e.vmovaps(e.ptr[addr + 0 * 16], e.xmm0);
-        e.vmovaps(e.ptr[addr + 1 * 16], e.xmm0);
-        break;
-      case 128:
-        e.vmovaps(e.ptr[addr + 0 * 16], e.xmm0);
-        e.vmovaps(e.ptr[addr + 1 * 16], e.xmm0);
-        e.vmovaps(e.ptr[addr + 2 * 16], e.xmm0);
-        e.vmovaps(e.ptr[addr + 3 * 16], e.xmm0);
-        e.vmovaps(e.ptr[addr + 4 * 16], e.xmm0);
-        e.vmovaps(e.ptr[addr + 5 * 16], e.xmm0);
-        e.vmovaps(e.ptr[addr + 6 * 16], e.xmm0);
-        e.vmovaps(e.ptr[addr + 7 * 16], e.xmm0);
-        break;
-      default:
-        assert_unhandled_case(i.src3.constant());
-        break;
-    }
-    if (IsTracingData()) {
-      addr = ComputeMemoryAddress(e, i.src1);
-      e.mov(e.r9, i.src3.constant());
-      e.mov(e.r8, i.src2.constant());
-      e.lea(e.rdx, e.ptr[addr]);
-      e.CallNative(reinterpret_cast<void*>(TraceMemset));
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_MEMSET, MEMSET_I64_I8_I64);
-
 // ============================================================================
 // OPCODE_MAX
 // ============================================================================
@@ -2721,51 +488,6 @@ struct MAX_V128 : Sequence<MAX_V128, I<OPCODE_MAX, V128Op, V128Op, V128Op>> {
 };
 EMITTER_OPCODE_TABLE(OPCODE_MAX, MAX_F32, MAX_F64, MAX_V128);
 
-// ============================================================================
-// OPCODE_VECTOR_MAX
-// ============================================================================
-struct VECTOR_MAX
-    : Sequence<VECTOR_MAX, I<OPCODE_VECTOR_MAX, V128Op, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    EmitCommutativeBinaryXmmOp(
-        e, i, [&i](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) {
-          uint32_t part_type = i.instr->flags >> 8;
-          if (i.instr->flags & ARITHMETIC_UNSIGNED) {
-            switch (part_type) {
-              case INT8_TYPE:
-                e.vpmaxub(dest, src1, src2);
-                break;
-              case INT16_TYPE:
-                e.vpmaxuw(dest, src1, src2);
-                break;
-              case INT32_TYPE:
-                e.vpmaxud(dest, src1, src2);
-                break;
-              default:
-                assert_unhandled_case(part_type);
-                break;
-            }
-          } else {
-            switch (part_type) {
-              case INT8_TYPE:
-                e.vpmaxsb(dest, src1, src2);
-                break;
-              case INT16_TYPE:
-                e.vpmaxsw(dest, src1, src2);
-                break;
-              case INT32_TYPE:
-                e.vpmaxsd(dest, src1, src2);
-                break;
-              default:
-                assert_unhandled_case(part_type);
-                break;
-            }
-          }
-        });
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_MAX, VECTOR_MAX);
-
 // ============================================================================
 // OPCODE_MIN
 // ============================================================================
@@ -2856,51 +578,6 @@ struct MIN_V128 : Sequence<MIN_V128, I<OPCODE_MIN, V128Op, V128Op, V128Op>> {
 EMITTER_OPCODE_TABLE(OPCODE_MIN, MIN_I8, MIN_I16, MIN_I32, MIN_I64, MIN_F32,
                      MIN_F64, MIN_V128);
 
-// ============================================================================
-// OPCODE_VECTOR_MIN
-// ============================================================================
-struct VECTOR_MIN
-    : Sequence<VECTOR_MIN, I<OPCODE_VECTOR_MIN, V128Op, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    EmitCommutativeBinaryXmmOp(
-        e, i, [&i](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) {
-          uint32_t part_type = i.instr->flags >> 8;
-          if (i.instr->flags & ARITHMETIC_UNSIGNED) {
-            switch (part_type) {
-              case INT8_TYPE:
-                e.vpminub(dest, src1, src2);
-                break;
-              case INT16_TYPE:
-                e.vpminuw(dest, src1, src2);
-                break;
-              case INT32_TYPE:
-                e.vpminud(dest, src1, src2);
-                break;
-              default:
-                assert_unhandled_case(part_type);
-                break;
-            }
-          } else {
-            switch (part_type) {
-              case INT8_TYPE:
-                e.vpminsb(dest, src1, src2);
-                break;
-              case INT16_TYPE:
-                e.vpminsw(dest, src1, src2);
-                break;
-              case INT32_TYPE:
-                e.vpminsd(dest, src1, src2);
-                break;
-              default:
-                assert_unhandled_case(part_type);
-                break;
-            }
-          }
-        });
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_MIN, VECTOR_MIN);
-
 // ============================================================================
 // OPCODE_SELECT
 // ============================================================================
@@ -3367,7 +1044,8 @@ EMITTER_ASSOCIATIVE_COMPARE_XX(ULE, setbe, setae);
 EMITTER_ASSOCIATIVE_COMPARE_XX(UGT, seta, setb);
 EMITTER_ASSOCIATIVE_COMPARE_XX(UGE, setae, setbe);
 
-// http://x86.renejeschke.de/html/file_module_x86_id_288.html
+// https://web.archive.org/web/20171129015931/https://x86.renejeschke.de/html/file_module_x86_id_288.html
+// Original link: https://x86.renejeschke.de/html/file_module_x86_id_288.html
 #define EMITTER_ASSOCIATIVE_COMPARE_FLT_XX(op, instr)                 \
   struct COMPARE_##op##_F32                                           \
       : Sequence<COMPARE_##op##_F32,                                  \
@@ -3416,213 +1094,6 @@ struct DID_SATURATE
 };
 EMITTER_OPCODE_TABLE(OPCODE_DID_SATURATE, DID_SATURATE);
 
-// ============================================================================
-// OPCODE_VECTOR_COMPARE_EQ
-// ============================================================================
-struct VECTOR_COMPARE_EQ_V128
-    : Sequence<VECTOR_COMPARE_EQ_V128,
-               I<OPCODE_VECTOR_COMPARE_EQ, V128Op, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    EmitCommutativeBinaryXmmOp(
-        e, i, [&i](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) {
-          switch (i.instr->flags) {
-            case INT8_TYPE:
-              e.vpcmpeqb(dest, src1, src2);
-              break;
-            case INT16_TYPE:
-              e.vpcmpeqw(dest, src1, src2);
-              break;
-            case INT32_TYPE:
-              e.vpcmpeqd(dest, src1, src2);
-              break;
-            case FLOAT32_TYPE:
-              e.vcmpeqps(dest, src1, src2);
-              break;
-          }
-        });
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_COMPARE_EQ, VECTOR_COMPARE_EQ_V128);
-
-// ============================================================================
-// OPCODE_VECTOR_COMPARE_SGT
-// ============================================================================
-struct VECTOR_COMPARE_SGT_V128
-    : Sequence<VECTOR_COMPARE_SGT_V128,
-               I<OPCODE_VECTOR_COMPARE_SGT, V128Op, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    EmitAssociativeBinaryXmmOp(
-        e, i, [&i](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) {
-          switch (i.instr->flags) {
-            case INT8_TYPE:
-              e.vpcmpgtb(dest, src1, src2);
-              break;
-            case INT16_TYPE:
-              e.vpcmpgtw(dest, src1, src2);
-              break;
-            case INT32_TYPE:
-              e.vpcmpgtd(dest, src1, src2);
-              break;
-            case FLOAT32_TYPE:
-              e.vcmpgtps(dest, src1, src2);
-              break;
-          }
-        });
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_COMPARE_SGT, VECTOR_COMPARE_SGT_V128);
-
-// ============================================================================
-// OPCODE_VECTOR_COMPARE_SGE
-// ============================================================================
-struct VECTOR_COMPARE_SGE_V128
-    : Sequence<VECTOR_COMPARE_SGE_V128,
-               I<OPCODE_VECTOR_COMPARE_SGE, V128Op, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    EmitAssociativeBinaryXmmOp(
-        e, i, [&i](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) {
-          switch (i.instr->flags) {
-            case INT8_TYPE:
-              e.vpcmpeqb(e.xmm0, src1, src2);
-              e.vpcmpgtb(dest, src1, src2);
-              e.vpor(dest, e.xmm0);
-              break;
-            case INT16_TYPE:
-              e.vpcmpeqw(e.xmm0, src1, src2);
-              e.vpcmpgtw(dest, src1, src2);
-              e.vpor(dest, e.xmm0);
-              break;
-            case INT32_TYPE:
-              e.vpcmpeqd(e.xmm0, src1, src2);
-              e.vpcmpgtd(dest, src1, src2);
-              e.vpor(dest, e.xmm0);
-              break;
-            case FLOAT32_TYPE:
-              e.vcmpgeps(dest, src1, src2);
-              break;
-          }
-        });
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_COMPARE_SGE, VECTOR_COMPARE_SGE_V128);
-
-// ============================================================================
-// OPCODE_VECTOR_COMPARE_UGT
-// ============================================================================
-struct VECTOR_COMPARE_UGT_V128
-    : Sequence<VECTOR_COMPARE_UGT_V128,
-               I<OPCODE_VECTOR_COMPARE_UGT, V128Op, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    Xbyak::Address sign_addr = e.ptr[e.rax];  // dummy
-    switch (i.instr->flags) {
-      case INT8_TYPE:
-        sign_addr = e.GetXmmConstPtr(XMMSignMaskI8);
-        break;
-      case INT16_TYPE:
-        sign_addr = e.GetXmmConstPtr(XMMSignMaskI16);
-        break;
-      case INT32_TYPE:
-        sign_addr = e.GetXmmConstPtr(XMMSignMaskI32);
-        break;
-      case FLOAT32_TYPE:
-        sign_addr = e.GetXmmConstPtr(XMMSignMaskF32);
-        break;
-      default:
-        assert_always();
-        break;
-    }
-    if (i.src1.is_constant) {
-      // TODO(benvanik): make this constant.
-      e.LoadConstantXmm(e.xmm0, i.src1.constant());
-      e.vpxor(e.xmm0, sign_addr);
-    } else {
-      e.vpxor(e.xmm0, i.src1, sign_addr);
-    }
-    if (i.src2.is_constant) {
-      // TODO(benvanik): make this constant.
-      e.LoadConstantXmm(e.xmm1, i.src2.constant());
-      e.vpxor(e.xmm1, sign_addr);
-    } else {
-      e.vpxor(e.xmm1, i.src2, sign_addr);
-    }
-    switch (i.instr->flags) {
-      case INT8_TYPE:
-        e.vpcmpgtb(i.dest, e.xmm0, e.xmm1);
-        break;
-      case INT16_TYPE:
-        e.vpcmpgtw(i.dest, e.xmm0, e.xmm1);
-        break;
-      case INT32_TYPE:
-        e.vpcmpgtd(i.dest, e.xmm0, e.xmm1);
-        break;
-      case FLOAT32_TYPE:
-        e.vcmpgtps(i.dest, e.xmm0, e.xmm1);
-        break;
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_COMPARE_UGT, VECTOR_COMPARE_UGT_V128);
-
-// ============================================================================
-// OPCODE_VECTOR_COMPARE_UGE
-// ============================================================================
-struct VECTOR_COMPARE_UGE_V128
-    : Sequence<VECTOR_COMPARE_UGE_V128,
-               I<OPCODE_VECTOR_COMPARE_UGE, V128Op, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    Xbyak::Address sign_addr = e.ptr[e.rax];  // dummy
-    switch (i.instr->flags) {
-      case INT8_TYPE:
-        sign_addr = e.GetXmmConstPtr(XMMSignMaskI8);
-        break;
-      case INT16_TYPE:
-        sign_addr = e.GetXmmConstPtr(XMMSignMaskI16);
-        break;
-      case INT32_TYPE:
-        sign_addr = e.GetXmmConstPtr(XMMSignMaskI32);
-        break;
-      case FLOAT32_TYPE:
-        sign_addr = e.GetXmmConstPtr(XMMSignMaskF32);
-        break;
-    }
-    if (i.src1.is_constant) {
-      // TODO(benvanik): make this constant.
-      e.LoadConstantXmm(e.xmm0, i.src1.constant());
-      e.vpxor(e.xmm0, sign_addr);
-    } else {
-      e.vpxor(e.xmm0, i.src1, sign_addr);
-    }
-    if (i.src2.is_constant) {
-      // TODO(benvanik): make this constant.
-      e.LoadConstantXmm(e.xmm1, i.src2.constant());
-      e.vpxor(e.xmm1, sign_addr);
-    } else {
-      e.vpxor(e.xmm1, i.src2, sign_addr);
-    }
-    switch (i.instr->flags) {
-      case INT8_TYPE:
-        e.vpcmpeqb(e.xmm2, e.xmm0, e.xmm1);
-        e.vpcmpgtb(i.dest, e.xmm0, e.xmm1);
-        e.vpor(i.dest, e.xmm2);
-        break;
-      case INT16_TYPE:
-        e.vpcmpeqw(e.xmm2, e.xmm0, e.xmm1);
-        e.vpcmpgtw(i.dest, e.xmm0, e.xmm1);
-        e.vpor(i.dest, e.xmm2);
-        break;
-      case INT32_TYPE:
-        e.vpcmpeqd(e.xmm2, e.xmm0, e.xmm1);
-        e.vpcmpgtd(i.dest, e.xmm0, e.xmm1);
-        e.vpor(i.dest, e.xmm2);
-        break;
-      case FLOAT32_TYPE:
-        e.vcmpgeps(i.dest, e.xmm0, e.xmm1);
-        break;
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_COMPARE_UGE, VECTOR_COMPARE_UGE_V128);
-
 // ============================================================================
 // OPCODE_ADD
 // ============================================================================
@@ -3745,98 +1216,6 @@ struct ADD_CARRY_I64
 EMITTER_OPCODE_TABLE(OPCODE_ADD_CARRY, ADD_CARRY_I8, ADD_CARRY_I16,
                      ADD_CARRY_I32, ADD_CARRY_I64);
 
-// ============================================================================
-// OPCODE_VECTOR_ADD
-// ============================================================================
-struct VECTOR_ADD
-    : Sequence<VECTOR_ADD, I<OPCODE_VECTOR_ADD, V128Op, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    EmitCommutativeBinaryXmmOp(
-        e, i, [&i](X64Emitter& e, const Xmm& dest, Xmm src1, Xmm src2) {
-          const TypeName part_type =
-              static_cast<TypeName>(i.instr->flags & 0xFF);
-          const uint32_t arithmetic_flags = i.instr->flags >> 8;
-          bool is_unsigned = !!(arithmetic_flags & ARITHMETIC_UNSIGNED);
-          bool saturate = !!(arithmetic_flags & ARITHMETIC_SATURATE);
-          switch (part_type) {
-            case INT8_TYPE:
-              if (saturate) {
-                // TODO(benvanik): trace DID_SATURATE
-                if (is_unsigned) {
-                  e.vpaddusb(dest, src1, src2);
-                } else {
-                  e.vpaddsb(dest, src1, src2);
-                }
-              } else {
-                e.vpaddb(dest, src1, src2);
-              }
-              break;
-            case INT16_TYPE:
-              if (saturate) {
-                // TODO(benvanik): trace DID_SATURATE
-                if (is_unsigned) {
-                  e.vpaddusw(dest, src1, src2);
-                } else {
-                  e.vpaddsw(dest, src1, src2);
-                }
-              } else {
-                e.vpaddw(dest, src1, src2);
-              }
-              break;
-            case INT32_TYPE:
-              if (saturate) {
-                if (is_unsigned) {
-                  // xmm0 is the only temp register that can be used by
-                  // src1/src2.
-                  e.vpaddd(e.xmm1, src1, src2);
-
-                  // If result is smaller than either of the inputs, we've
-                  // overflowed (only need to check one input)
-                  // if (src1 > res) then overflowed
-                  // http://locklessinc.com/articles/sat_arithmetic/
-                  e.vpxor(e.xmm2, src1, e.GetXmmConstPtr(XMMSignMaskI32));
-                  e.vpxor(e.xmm0, e.xmm1, e.GetXmmConstPtr(XMMSignMaskI32));
-                  e.vpcmpgtd(e.xmm0, e.xmm2, e.xmm0);
-                  e.vpor(dest, e.xmm1, e.xmm0);
-                } else {
-                  e.vpaddd(e.xmm1, src1, src2);
-
-                  // Overflow results if two inputs are the same sign and the
-                  // result isn't the same sign. if ((s32b)(~(src1 ^ src2) &
-                  // (src1 ^ res)) < 0) then overflowed
-                  // http://locklessinc.com/articles/sat_arithmetic/
-                  e.vpxor(e.xmm2, src1, src2);
-                  e.vpxor(e.xmm3, src1, e.xmm1);
-                  e.vpandn(e.xmm2, e.xmm2, e.xmm3);
-
-                  // Set any negative overflowed elements of src1 to INT_MIN
-                  e.vpand(e.xmm3, src1, e.xmm2);
-                  e.vblendvps(e.xmm1, e.xmm1, e.GetXmmConstPtr(XMMSignMaskI32),
-                              e.xmm3);
-
-                  // Set any positive overflowed elements of src1 to INT_MAX
-                  e.vpandn(e.xmm3, src1, e.xmm2);
-                  e.vblendvps(dest, e.xmm1, e.GetXmmConstPtr(XMMAbsMaskPS),
-                              e.xmm3);
-                }
-              } else {
-                e.vpaddd(dest, src1, src2);
-              }
-              break;
-            case FLOAT32_TYPE:
-              assert_false(is_unsigned);
-              assert_false(saturate);
-              e.vaddps(dest, src1, src2);
-              break;
-            default:
-              assert_unhandled_case(part_type);
-              break;
-          }
-        });
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_ADD, VECTOR_ADD);
-
 // ============================================================================
 // OPCODE_SUB
 // ============================================================================
@@ -3902,97 +1281,6 @@ struct SUB_V128 : Sequence<SUB_V128, I<OPCODE_SUB, V128Op, V128Op, V128Op>> {
 EMITTER_OPCODE_TABLE(OPCODE_SUB, SUB_I8, SUB_I16, SUB_I32, SUB_I64, SUB_F32,
                      SUB_F64, SUB_V128);
 
-// ============================================================================
-// OPCODE_VECTOR_SUB
-// ============================================================================
-struct VECTOR_SUB
-    : Sequence<VECTOR_SUB, I<OPCODE_VECTOR_SUB, V128Op, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    EmitCommutativeBinaryXmmOp(
-        e, i, [&i](X64Emitter& e, const Xmm& dest, Xmm src1, Xmm src2) {
-          const TypeName part_type =
-              static_cast<TypeName>(i.instr->flags & 0xFF);
-          const uint32_t arithmetic_flags = i.instr->flags >> 8;
-          bool is_unsigned = !!(arithmetic_flags & ARITHMETIC_UNSIGNED);
-          bool saturate = !!(arithmetic_flags & ARITHMETIC_SATURATE);
-          switch (part_type) {
-            case INT8_TYPE:
-              if (saturate) {
-                // TODO(benvanik): trace DID_SATURATE
-                if (is_unsigned) {
-                  e.vpsubusb(dest, src1, src2);
-                } else {
-                  e.vpsubsb(dest, src1, src2);
-                }
-              } else {
-                e.vpsubb(dest, src1, src2);
-              }
-              break;
-            case INT16_TYPE:
-              if (saturate) {
-                // TODO(benvanik): trace DID_SATURATE
-                if (is_unsigned) {
-                  e.vpsubusw(dest, src1, src2);
-                } else {
-                  e.vpsubsw(dest, src1, src2);
-                }
-              } else {
-                e.vpsubw(dest, src1, src2);
-              }
-              break;
-            case INT32_TYPE:
-              if (saturate) {
-                if (is_unsigned) {
-                  // xmm0 is the only temp register that can be used by
-                  // src1/src2.
-                  e.vpsubd(e.xmm1, src1, src2);
-
-                  // If result is greater than either of the inputs, we've
-                  // underflowed (only need to check one input)
-                  // if (res > src1) then underflowed
-                  // http://locklessinc.com/articles/sat_arithmetic/
-                  e.vpxor(e.xmm2, src1, e.GetXmmConstPtr(XMMSignMaskI32));
-                  e.vpxor(e.xmm0, e.xmm1, e.GetXmmConstPtr(XMMSignMaskI32));
-                  e.vpcmpgtd(e.xmm0, e.xmm0, e.xmm2);
-                  e.vpandn(dest, e.xmm0, e.xmm1);
-                } else {
-                  e.vpsubd(e.xmm1, src1, src2);
-
-                  // We can only overflow if the signs of the operands are
-                  // opposite. If signs are opposite and result sign isn't the
-                  // same as src1's sign, we've overflowed. if ((s32b)((src1 ^
-                  // src2) & (src1 ^ res)) < 0) then overflowed
-                  // http://locklessinc.com/articles/sat_arithmetic/
-                  e.vpxor(e.xmm2, src1, src2);
-                  e.vpxor(e.xmm3, src1, e.xmm1);
-                  e.vpand(e.xmm2, e.xmm2, e.xmm3);
-
-                  // Set any negative overflowed elements of src1 to INT_MIN
-                  e.vpand(e.xmm3, src1, e.xmm2);
-                  e.vblendvps(e.xmm1, e.xmm1, e.GetXmmConstPtr(XMMSignMaskI32),
-                              e.xmm3);
-
-                  // Set any positive overflowed elements of src1 to INT_MAX
-                  e.vpandn(e.xmm3, src1, e.xmm2);
-                  e.vblendvps(dest, e.xmm1, e.GetXmmConstPtr(XMMAbsMaskPS),
-                              e.xmm3);
-                }
-              } else {
-                e.vpsubd(dest, src1, src2);
-              }
-              break;
-            case FLOAT32_TYPE:
-              e.vsubps(dest, src1, src2);
-              break;
-            default:
-              assert_unhandled_case(part_type);
-              break;
-          }
-        });
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_SUB, VECTOR_SUB);
-
 // ============================================================================
 // OPCODE_MUL
 // ============================================================================
@@ -5062,7 +2350,7 @@ EMITTER_OPCODE_TABLE(OPCODE_RECIP, RECIP_F32, RECIP_F64, RECIP_V128);
 // OPCODE_POW2
 // ============================================================================
 // TODO(benvanik): use approx here:
-//     http://jrfonseca.blogspot.com/2008/09/fast-sse2-pow-tables-or-polynomials.html
+//     https://jrfonseca.blogspot.com/2008/09/fast-sse2-pow-tables-or-polynomials.html
 struct POW2_F32 : Sequence<POW2_F32, I<OPCODE_POW2, F32Op, F32Op>> {
   static __m128 EmulatePow2(void*, __m128 src) {
     float src_value;
@@ -5072,7 +2360,7 @@ struct POW2_F32 : Sequence<POW2_F32, I<OPCODE_POW2, F32Op, F32Op>> {
   }
   static void Emit(X64Emitter& e, const EmitArgType& i) {
     assert_always();
-    e.lea(e.r8, e.StashXmm(0, i.src1));
+    e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
     e.CallNativeSafe(reinterpret_cast<void*>(EmulatePow2));
     e.vmovaps(i.dest, e.xmm0);
   }
@@ -5086,7 +2374,7 @@ struct POW2_F64 : Sequence<POW2_F64, I<OPCODE_POW2, F64Op, F64Op>> {
   }
   static void Emit(X64Emitter& e, const EmitArgType& i) {
     assert_always();
-    e.lea(e.r8, e.StashXmm(0, i.src1));
+    e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
     e.CallNativeSafe(reinterpret_cast<void*>(EmulatePow2));
     e.vmovaps(i.dest, e.xmm0);
   }
@@ -5101,7 +2389,7 @@ struct POW2_V128 : Sequence<POW2_V128, I<OPCODE_POW2, V128Op, V128Op>> {
     return _mm_load_ps(values);
   }
   static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.lea(e.r8, e.StashXmm(0, i.src1));
+    e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
     e.CallNativeSafe(reinterpret_cast<void*>(EmulatePow2));
     e.vmovaps(i.dest, e.xmm0);
   }
@@ -5112,7 +2400,7 @@ EMITTER_OPCODE_TABLE(OPCODE_POW2, POW2_F32, POW2_F64, POW2_V128);
 // OPCODE_LOG2
 // ============================================================================
 // TODO(benvanik): use approx here:
-//     http://jrfonseca.blogspot.com/2008/09/fast-sse2-pow-tables-or-polynomials.html
+//     https://jrfonseca.blogspot.com/2008/09/fast-sse2-pow-tables-or-polynomials.html
 // TODO(benvanik): this emulated fn destroys all xmm registers! don't do it!
 struct LOG2_F32 : Sequence<LOG2_F32, I<OPCODE_LOG2, F32Op, F32Op>> {
   static __m128 EmulateLog2(void*, __m128 src) {
@@ -5123,7 +2411,7 @@ struct LOG2_F32 : Sequence<LOG2_F32, I<OPCODE_LOG2, F32Op, F32Op>> {
   }
   static void Emit(X64Emitter& e, const EmitArgType& i) {
     assert_always();
-    e.lea(e.r8, e.StashXmm(0, i.src1));
+    e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
     e.CallNativeSafe(reinterpret_cast<void*>(EmulateLog2));
     e.vmovaps(i.dest, e.xmm0);
   }
@@ -5137,7 +2425,7 @@ struct LOG2_F64 : Sequence<LOG2_F64, I<OPCODE_LOG2, F64Op, F64Op>> {
   }
   static void Emit(X64Emitter& e, const EmitArgType& i) {
     assert_always();
-    e.lea(e.r8, e.StashXmm(0, i.src1));
+    e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
     e.CallNativeSafe(reinterpret_cast<void*>(EmulateLog2));
     e.vmovaps(i.dest, e.xmm0);
   }
@@ -5152,7 +2440,7 @@ struct LOG2_V128 : Sequence<LOG2_V128, I<OPCODE_LOG2, V128Op, V128Op>> {
     return _mm_load_ps(values);
   }
   static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.lea(e.r8, e.StashXmm(0, i.src1));
+    e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
     e.CallNativeSafe(reinterpret_cast<void*>(EmulateLog2));
     e.vmovaps(i.dest, e.xmm0);
   }
@@ -5166,7 +2454,7 @@ struct DOT_PRODUCT_3_V128
     : Sequence<DOT_PRODUCT_3_V128,
                I<OPCODE_DOT_PRODUCT_3, F32Op, V128Op, V128Op>> {
   static void Emit(X64Emitter& e, const EmitArgType& i) {
-    // http://msdn.microsoft.com/en-us/library/bb514054(v=vs.90).aspx
+    // https://msdn.microsoft.com/en-us/library/bb514054(v=vs.90).aspx
     EmitCommutativeBinaryXmmOp(e, i,
                                [](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) {
                                  // TODO(benvanik): apparently this is very slow
@@ -5184,7 +2472,7 @@ struct DOT_PRODUCT_4_V128
     : Sequence<DOT_PRODUCT_4_V128,
                I<OPCODE_DOT_PRODUCT_4, F32Op, V128Op, V128Op>> {
   static void Emit(X64Emitter& e, const EmitArgType& i) {
-    // http://msdn.microsoft.com/en-us/library/bb514054(v=vs.90).aspx
+    // https://msdn.microsoft.com/en-us/library/bb514054(v=vs.90).aspx
     EmitCommutativeBinaryXmmOp(e, i,
                                [](X64Emitter& e, Xmm dest, Xmm src1, Xmm src2) {
                                  // TODO(benvanik): apparently this is very slow
@@ -5417,11 +2705,11 @@ struct SHL_V128 : Sequence<SHL_V128, I<OPCODE_SHL, V128Op, V128Op, I8Op>> {
   static void Emit(X64Emitter& e, const EmitArgType& i) {
     // TODO(benvanik): native version (with shift magic).
     if (i.src2.is_constant) {
-      e.mov(e.r9, i.src2.constant());
+      e.mov(e.GetNativeParam(1), i.src2.constant());
     } else {
-      e.mov(e.r9, i.src2);
+      e.mov(e.GetNativeParam(1), i.src2);
     }
-    e.lea(e.r8, e.StashXmm(0, i.src1));
+    e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
     e.CallNativeSafe(reinterpret_cast<void*>(EmulateShlV128));
     e.vmovaps(i.dest, e.xmm0);
   }
@@ -5494,11 +2782,11 @@ struct SHR_V128 : Sequence<SHR_V128, I<OPCODE_SHR, V128Op, V128Op, I8Op>> {
   static void Emit(X64Emitter& e, const EmitArgType& i) {
     // TODO(benvanik): native version (with shift magic).
     if (i.src2.is_constant) {
-      e.mov(e.r9, i.src2.constant());
+      e.mov(e.GetNativeParam(1), i.src2.constant());
     } else {
-      e.mov(e.r9, i.src2);
+      e.mov(e.GetNativeParam(1), i.src2);
     }
-    e.lea(e.r8, e.StashXmm(0, i.src1));
+    e.lea(e.GetNativeParam(0), e.StashXmm(0, i.src1));
     e.CallNativeSafe(reinterpret_cast<void*>(EmulateShrV128));
     e.vmovaps(i.dest, e.xmm0);
   }
@@ -5567,563 +2855,6 @@ struct SHA_I64 : Sequence<SHA_I64, I<OPCODE_SHA, I64Op, I64Op, I8Op>> {
 };
 EMITTER_OPCODE_TABLE(OPCODE_SHA, SHA_I8, SHA_I16, SHA_I32, SHA_I64);
 
-// ============================================================================
-// OPCODE_VECTOR_SHL
-// ============================================================================
-struct VECTOR_SHL_V128
-    : Sequence<VECTOR_SHL_V128, I<OPCODE_VECTOR_SHL, V128Op, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    switch (i.instr->flags) {
-      case INT8_TYPE:
-        EmitInt8(e, i);
-        break;
-      case INT16_TYPE:
-        EmitInt16(e, i);
-        break;
-      case INT32_TYPE:
-        EmitInt32(e, i);
-        break;
-      default:
-        assert_always();
-        break;
-    }
-  }
-  static __m128i EmulateVectorShlI8(void*, __m128i src1, __m128i src2) {
-    alignas(16) uint8_t value[16];
-    alignas(16) uint8_t shamt[16];
-    _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
-    for (size_t i = 0; i < 16; ++i) {
-      value[i] = value[i] << (shamt[i] & 0x7);
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(value));
-  }
-  static void EmitInt8(X64Emitter& e, const EmitArgType& i) {
-    // TODO(benvanik): native version (with shift magic).
-    if (i.src2.is_constant) {
-      e.LoadConstantXmm(e.xmm0, i.src2.constant());
-      e.lea(e.r9, e.StashXmm(1, e.xmm0));
-    } else {
-      e.lea(e.r9, e.StashXmm(1, i.src2));
-    }
-    e.lea(e.r8, e.StashXmm(0, i.src1));
-    e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShlI8));
-    e.vmovaps(i.dest, e.xmm0);
-  }
-  static __m128i EmulateVectorShlI16(void*, __m128i src1, __m128i src2) {
-    alignas(16) uint16_t value[8];
-    alignas(16) uint16_t shamt[8];
-    _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
-    for (size_t i = 0; i < 8; ++i) {
-      value[i] = value[i] << (shamt[i] & 0xF);
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(value));
-  }
-  static void EmitInt16(X64Emitter& e, const EmitArgType& i) {
-    if (i.src2.is_constant) {
-      const auto& shamt = i.src2.constant();
-      bool all_same = true;
-      for (size_t n = 0; n < 8 - n; ++n) {
-        if (shamt.u16[n] != shamt.u16[n + 1]) {
-          all_same = false;
-          break;
-        }
-      }
-      if (all_same) {
-        // Every count is the same, so we can use vpsllw.
-        e.vpsllw(i.dest, i.src1, shamt.u16[0] & 0xF);
-        return;
-      }
-    }
-
-    // Shift 8 words in src1 by amount specified in src2.
-    Xbyak::Label emu, end;
-
-    // Only bother with this check if shift amt isn't constant.
-    if (!i.src2.is_constant) {
-      // See if the shift is equal first for a shortcut.
-      e.vpshuflw(e.xmm0, i.src2, 0b00000000);
-      e.vpshufd(e.xmm0, e.xmm0, 0b00000000);
-      e.vpxor(e.xmm1, e.xmm0, i.src2);
-      e.vptest(e.xmm1, e.xmm1);
-      e.jnz(emu);
-
-      // Equal. Shift using vpsllw.
-      e.mov(e.rax, 0xF);
-      e.vmovq(e.xmm1, e.rax);
-      e.vpand(e.xmm0, e.xmm0, e.xmm1);
-      e.vpsllw(i.dest, i.src1, e.xmm0);
-      e.jmp(end);
-    }
-
-    // TODO(benvanik): native version (with shift magic).
-    e.L(emu);
-    if (i.src2.is_constant) {
-      e.LoadConstantXmm(e.xmm0, i.src2.constant());
-      e.lea(e.r9, e.StashXmm(1, e.xmm0));
-    } else {
-      e.lea(e.r9, e.StashXmm(1, i.src2));
-    }
-    e.lea(e.r8, e.StashXmm(0, i.src1));
-    e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShlI16));
-    e.vmovaps(i.dest, e.xmm0);
-
-    e.L(end);
-  }
-  static __m128i EmulateVectorShlI32(void*, __m128i src1, __m128i src2) {
-    alignas(16) uint32_t value[4];
-    alignas(16) uint32_t shamt[4];
-    _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
-    for (size_t i = 0; i < 4; ++i) {
-      value[i] = value[i] << (shamt[i] & 0x1F);
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(value));
-  }
-  static void EmitInt32(X64Emitter& e, const EmitArgType& i) {
-    if (i.src2.is_constant) {
-      const auto& shamt = i.src2.constant();
-      bool all_same = true;
-      for (size_t n = 0; n < 4 - n; ++n) {
-        if (shamt.u32[n] != shamt.u32[n + 1]) {
-          all_same = false;
-          break;
-        }
-      }
-      if (all_same) {
-        // Every count is the same, so we can use vpslld.
-        e.vpslld(i.dest, i.src1, shamt.u8[0] & 0x1F);
-        return;
-      }
-    }
-
-    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
-      if (i.src2.is_constant) {
-        const auto& shamt = i.src2.constant();
-        // Counts differ, so pre-mask and load constant.
-        vec128_t masked = i.src2.constant();
-        for (size_t n = 0; n < 4; ++n) {
-          masked.u32[n] &= 0x1F;
-        }
-        e.LoadConstantXmm(e.xmm0, masked);
-        e.vpsllvd(i.dest, i.src1, e.xmm0);
-      } else {
-        // Fully variable shift.
-        // src shift mask may have values >31, and x86 sets to zero when
-        // that happens so we mask.
-        e.vandps(e.xmm0, i.src2, e.GetXmmConstPtr(XMMShiftMaskPS));
-        e.vpsllvd(i.dest, i.src1, e.xmm0);
-      }
-    } else {
-      // Shift 4 words in src1 by amount specified in src2.
-      Xbyak::Label emu, end;
-
-      // See if the shift is equal first for a shortcut.
-      // Only bother with this check if shift amt isn't constant.
-      if (!i.src2.is_constant) {
-        e.vpshufd(e.xmm0, i.src2, 0b00000000);
-        e.vpxor(e.xmm1, e.xmm0, i.src2);
-        e.vptest(e.xmm1, e.xmm1);
-        e.jnz(emu);
-
-        // Equal. Shift using vpsrad.
-        e.mov(e.rax, 0x1F);
-        e.vmovq(e.xmm1, e.rax);
-        e.vpand(e.xmm0, e.xmm0, e.xmm1);
-        e.vpslld(i.dest, i.src1, e.xmm0);
-        e.jmp(end);
-      }
-
-      // TODO(benvanik): native version (with shift magic).
-      e.L(emu);
-      if (i.src2.is_constant) {
-        e.LoadConstantXmm(e.xmm0, i.src2.constant());
-        e.lea(e.r9, e.StashXmm(1, e.xmm0));
-      } else {
-        e.lea(e.r9, e.StashXmm(1, i.src2));
-      }
-      e.lea(e.r8, e.StashXmm(0, i.src1));
-      e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShlI32));
-      e.vmovaps(i.dest, e.xmm0);
-
-      e.L(end);
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_SHL, VECTOR_SHL_V128);
-
-// ============================================================================
-// OPCODE_VECTOR_SHR
-// ============================================================================
-struct VECTOR_SHR_V128
-    : Sequence<VECTOR_SHR_V128, I<OPCODE_VECTOR_SHR, V128Op, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    switch (i.instr->flags) {
-      case INT8_TYPE:
-        EmitInt8(e, i);
-        break;
-      case INT16_TYPE:
-        EmitInt16(e, i);
-        break;
-      case INT32_TYPE:
-        EmitInt32(e, i);
-        break;
-      default:
-        assert_always();
-        break;
-    }
-  }
-  static __m128i EmulateVectorShrI8(void*, __m128i src1, __m128i src2) {
-    alignas(16) uint8_t value[16];
-    alignas(16) uint8_t shamt[16];
-    _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
-    for (size_t i = 0; i < 16; ++i) {
-      value[i] = value[i] >> (shamt[i] & 0x7);
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(value));
-  }
-  static void EmitInt8(X64Emitter& e, const EmitArgType& i) {
-    // TODO(benvanik): native version (with shift magic).
-    if (i.src2.is_constant) {
-      e.LoadConstantXmm(e.xmm0, i.src2.constant());
-      e.lea(e.r9, e.StashXmm(1, e.xmm0));
-    } else {
-      e.lea(e.r9, e.StashXmm(1, i.src2));
-    }
-    e.lea(e.r8, e.StashXmm(0, i.src1));
-    e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShrI8));
-    e.vmovaps(i.dest, e.xmm0);
-  }
-  static __m128i EmulateVectorShrI16(void*, __m128i src1, __m128i src2) {
-    alignas(16) uint16_t value[8];
-    alignas(16) uint16_t shamt[8];
-    _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
-    for (size_t i = 0; i < 8; ++i) {
-      value[i] = value[i] >> (shamt[i] & 0xF);
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(value));
-  }
-  static void EmitInt16(X64Emitter& e, const EmitArgType& i) {
-    if (i.src2.is_constant) {
-      const auto& shamt = i.src2.constant();
-      bool all_same = true;
-      for (size_t n = 0; n < 8 - n; ++n) {
-        if (shamt.u16[n] != shamt.u16[n + 1]) {
-          all_same = false;
-          break;
-        }
-      }
-      if (all_same) {
-        // Every count is the same, so we can use vpsllw.
-        e.vpsrlw(i.dest, i.src1, shamt.u16[0] & 0xF);
-        return;
-      }
-    }
-
-    // Shift 8 words in src1 by amount specified in src2.
-    Xbyak::Label emu, end;
-
-    // See if the shift is equal first for a shortcut.
-    // Only bother with this check if shift amt isn't constant.
-    if (!i.src2.is_constant) {
-      e.vpshuflw(e.xmm0, i.src2, 0b00000000);
-      e.vpshufd(e.xmm0, e.xmm0, 0b00000000);
-      e.vpxor(e.xmm1, e.xmm0, i.src2);
-      e.vptest(e.xmm1, e.xmm1);
-      e.jnz(emu);
-
-      // Equal. Shift using vpsrlw.
-      e.mov(e.rax, 0xF);
-      e.vmovq(e.xmm1, e.rax);
-      e.vpand(e.xmm0, e.xmm0, e.xmm1);
-      e.vpsrlw(i.dest, i.src1, e.xmm0);
-      e.jmp(end);
-    }
-
-    // TODO(benvanik): native version (with shift magic).
-    e.L(emu);
-    if (i.src2.is_constant) {
-      e.LoadConstantXmm(e.xmm0, i.src2.constant());
-      e.lea(e.r9, e.StashXmm(1, e.xmm0));
-    } else {
-      e.lea(e.r9, e.StashXmm(1, i.src2));
-    }
-    e.lea(e.r8, e.StashXmm(0, i.src1));
-    e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShrI16));
-    e.vmovaps(i.dest, e.xmm0);
-
-    e.L(end);
-  }
-  static __m128i EmulateVectorShrI32(void*, __m128i src1, __m128i src2) {
-    alignas(16) uint32_t value[4];
-    alignas(16) uint32_t shamt[4];
-    _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
-    for (size_t i = 0; i < 4; ++i) {
-      value[i] = value[i] >> (shamt[i] & 0x1F);
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(value));
-  }
-  static void EmitInt32(X64Emitter& e, const EmitArgType& i) {
-    if (i.src2.is_constant) {
-      const auto& shamt = i.src2.constant();
-      bool all_same = true;
-      for (size_t n = 0; n < 4 - n; ++n) {
-        if (shamt.u32[n] != shamt.u32[n + 1]) {
-          all_same = false;
-          break;
-        }
-      }
-      if (all_same) {
-        // Every count is the same, so we can use vpsrld.
-        e.vpsrld(i.dest, i.src1, shamt.u8[0] & 0x1F);
-        return;
-      } else {
-        if (e.IsFeatureEnabled(kX64EmitAVX2)) {
-          // Counts differ, so pre-mask and load constant.
-          vec128_t masked = i.src2.constant();
-          for (size_t n = 0; n < 4; ++n) {
-            masked.u32[n] &= 0x1F;
-          }
-          e.LoadConstantXmm(e.xmm0, masked);
-          e.vpsrlvd(i.dest, i.src1, e.xmm0);
-          return;
-        }
-      }
-    }
-
-    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
-      // Fully variable shift.
-      // src shift mask may have values >31, and x86 sets to zero when
-      // that happens so we mask.
-      e.vandps(e.xmm0, i.src2, e.GetXmmConstPtr(XMMShiftMaskPS));
-      e.vpsrlvd(i.dest, i.src1, e.xmm0);
-    } else {
-      // Shift 4 words in src1 by amount specified in src2.
-      Xbyak::Label emu, end;
-
-      // See if the shift is equal first for a shortcut.
-      // Only bother with this check if shift amt isn't constant.
-      if (!i.src2.is_constant) {
-        e.vpshufd(e.xmm0, i.src2, 0b00000000);
-        e.vpxor(e.xmm1, e.xmm0, i.src2);
-        e.vptest(e.xmm1, e.xmm1);
-        e.jnz(emu);
-
-        // Equal. Shift using vpsrld.
-        e.mov(e.rax, 0x1F);
-        e.vmovq(e.xmm1, e.rax);
-        e.vpand(e.xmm0, e.xmm0, e.xmm1);
-        e.vpsrld(i.dest, i.src1, e.xmm0);
-        e.jmp(end);
-      }
-
-      // TODO(benvanik): native version.
-      e.L(emu);
-      if (i.src2.is_constant) {
-        e.LoadConstantXmm(e.xmm0, i.src2.constant());
-        e.lea(e.r9, e.StashXmm(1, e.xmm0));
-      } else {
-        e.lea(e.r9, e.StashXmm(1, i.src2));
-      }
-      e.lea(e.r8, e.StashXmm(0, i.src1));
-      e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShrI32));
-      e.vmovaps(i.dest, e.xmm0);
-
-      e.L(end);
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_SHR, VECTOR_SHR_V128);
-
-// ============================================================================
-// OPCODE_VECTOR_SHA
-// ============================================================================
-struct VECTOR_SHA_V128
-    : Sequence<VECTOR_SHA_V128, I<OPCODE_VECTOR_SHA, V128Op, V128Op, V128Op>> {
-  static __m128i EmulateVectorShaI8(void*, __m128i src1, __m128i src2) {
-    alignas(16) int8_t value[16];
-    alignas(16) int8_t shamt[16];
-    _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
-    for (size_t i = 0; i < 16; ++i) {
-      value[i] = value[i] >> (shamt[i] & 0x7);
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(value));
-  }
-
-  static void EmitInt8(X64Emitter& e, const EmitArgType& i) {
-    // TODO(benvanik): native version (with shift magic).
-    if (i.src2.is_constant) {
-      e.LoadConstantXmm(e.xmm0, i.src2.constant());
-      e.lea(e.r9, e.StashXmm(1, e.xmm0));
-    } else {
-      e.lea(e.r9, e.StashXmm(1, i.src2));
-    }
-    e.lea(e.r8, e.StashXmm(0, i.src1));
-    e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShaI8));
-    e.vmovaps(i.dest, e.xmm0);
-  }
-
-  static __m128i EmulateVectorShaI16(void*, __m128i src1, __m128i src2) {
-    alignas(16) int16_t value[8];
-    alignas(16) int16_t shamt[8];
-    _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
-    for (size_t i = 0; i < 8; ++i) {
-      value[i] = value[i] >> (shamt[i] & 0xF);
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(value));
-  }
-
-  static void EmitInt16(X64Emitter& e, const EmitArgType& i) {
-    if (i.src2.is_constant) {
-      const auto& shamt = i.src2.constant();
-      bool all_same = true;
-      for (size_t n = 0; n < 8 - n; ++n) {
-        if (shamt.u16[n] != shamt.u16[n + 1]) {
-          all_same = false;
-          break;
-        }
-      }
-      if (all_same) {
-        // Every count is the same, so we can use vpsraw.
-        e.vpsraw(i.dest, i.src1, shamt.u16[0] & 0xF);
-        return;
-      }
-    }
-
-    // Shift 8 words in src1 by amount specified in src2.
-    Xbyak::Label emu, end;
-
-    // See if the shift is equal first for a shortcut.
-    // Only bother with this check if shift amt isn't constant.
-    if (!i.src2.is_constant) {
-      e.vpshuflw(e.xmm0, i.src2, 0b00000000);
-      e.vpshufd(e.xmm0, e.xmm0, 0b00000000);
-      e.vpxor(e.xmm1, e.xmm0, i.src2);
-      e.vptest(e.xmm1, e.xmm1);
-      e.jnz(emu);
-
-      // Equal. Shift using vpsraw.
-      e.mov(e.rax, 0xF);
-      e.vmovq(e.xmm1, e.rax);
-      e.vpand(e.xmm0, e.xmm0, e.xmm1);
-      e.vpsraw(i.dest, i.src1, e.xmm0);
-      e.jmp(end);
-    }
-
-    // TODO(benvanik): native version (with shift magic).
-    e.L(emu);
-    if (i.src2.is_constant) {
-      e.LoadConstantXmm(e.xmm0, i.src2.constant());
-      e.lea(e.r9, e.StashXmm(1, e.xmm0));
-    } else {
-      e.lea(e.r9, e.StashXmm(1, i.src2));
-    }
-    e.lea(e.r8, e.StashXmm(0, i.src1));
-    e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShaI16));
-    e.vmovaps(i.dest, e.xmm0);
-
-    e.L(end);
-  }
-
-  static __m128i EmulateVectorShaI32(void*, __m128i src1, __m128i src2) {
-    alignas(16) int32_t value[4];
-    alignas(16) int32_t shamt[4];
-    _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
-    for (size_t i = 0; i < 4; ++i) {
-      value[i] = value[i] >> (shamt[i] & 0x1F);
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(value));
-  }
-
-  static void EmitInt32(X64Emitter& e, const EmitArgType& i) {
-    if (i.src2.is_constant) {
-      const auto& shamt = i.src2.constant();
-      bool all_same = true;
-      for (size_t n = 0; n < 4 - n; ++n) {
-        if (shamt.u32[n] != shamt.u32[n + 1]) {
-          all_same = false;
-          break;
-        }
-      }
-      if (all_same) {
-        // Every count is the same, so we can use vpsrad.
-        e.vpsrad(i.dest, i.src1, shamt.u32[0] & 0x1F);
-        return;
-      }
-    }
-
-    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
-      // src shift mask may have values >31, and x86 sets to zero when
-      // that happens so we mask.
-      if (i.src2.is_constant) {
-        e.LoadConstantXmm(e.xmm0, i.src2.constant());
-        e.vandps(e.xmm0, e.GetXmmConstPtr(XMMShiftMaskPS));
-      } else {
-        e.vandps(e.xmm0, i.src2, e.GetXmmConstPtr(XMMShiftMaskPS));
-      }
-      e.vpsravd(i.dest, i.src1, e.xmm0);
-    } else {
-      // Shift 4 words in src1 by amount specified in src2.
-      Xbyak::Label emu, end;
-
-      // See if the shift is equal first for a shortcut.
-      // Only bother with this check if shift amt isn't constant.
-      if (!i.src2.is_constant) {
-        e.vpshufd(e.xmm0, i.src2, 0b00000000);
-        e.vpxor(e.xmm1, e.xmm0, i.src2);
-        e.vptest(e.xmm1, e.xmm1);
-        e.jnz(emu);
-
-        // Equal. Shift using vpsrad.
-        e.mov(e.rax, 0x1F);
-        e.vmovq(e.xmm1, e.rax);
-        e.vpand(e.xmm0, e.xmm0, e.xmm1);
-        e.vpsrad(i.dest, i.src1, e.xmm0);
-        e.jmp(end);
-      }
-
-      // TODO(benvanik): native version.
-      e.L(emu);
-      if (i.src2.is_constant) {
-        e.LoadConstantXmm(e.xmm0, i.src2.constant());
-        e.lea(e.r9, e.StashXmm(1, e.xmm0));
-      } else {
-        e.lea(e.r9, e.StashXmm(1, i.src2));
-      }
-      e.lea(e.r8, e.StashXmm(0, i.src1));
-      e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorShaI32));
-      e.vmovaps(i.dest, e.xmm0);
-
-      e.L(end);
-    }
-  }
-
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    switch (i.instr->flags) {
-      case INT8_TYPE:
-        EmitInt8(e, i);
-        break;
-      case INT16_TYPE:
-        EmitInt16(e, i);
-        break;
-      case INT32_TYPE:
-        EmitInt32(e, i);
-        break;
-      default:
-        assert_always();
-        break;
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_SHA, VECTOR_SHA_V128);
-
 // ============================================================================
 // OPCODE_ROTATE_LEFT
 // ============================================================================
@@ -6182,196 +2913,6 @@ struct ROTATE_LEFT_I64
 EMITTER_OPCODE_TABLE(OPCODE_ROTATE_LEFT, ROTATE_LEFT_I8, ROTATE_LEFT_I16,
                      ROTATE_LEFT_I32, ROTATE_LEFT_I64);
 
-// ============================================================================
-// OPCODE_VECTOR_ROTATE_LEFT
-// ============================================================================
-// TODO(benvanik): AVX512 has a native variable rotate (rolv).
-struct VECTOR_ROTATE_LEFT_V128
-    : Sequence<VECTOR_ROTATE_LEFT_V128,
-               I<OPCODE_VECTOR_ROTATE_LEFT, V128Op, V128Op, V128Op>> {
-  static __m128i EmulateVectorRotateLeftI8(void*, __m128i src1, __m128i src2) {
-    alignas(16) uint8_t value[16];
-    alignas(16) uint8_t shamt[16];
-    _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
-    for (size_t i = 0; i < 16; ++i) {
-      value[i] = xe::rotate_left<uint8_t>(value[i], shamt[i] & 0x7);
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(value));
-  }
-  static __m128i EmulateVectorRotateLeftI16(void*, __m128i src1, __m128i src2) {
-    alignas(16) uint16_t value[8];
-    alignas(16) uint16_t shamt[8];
-    _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
-    for (size_t i = 0; i < 8; ++i) {
-      value[i] = xe::rotate_left<uint16_t>(value[i], shamt[i] & 0xF);
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(value));
-  }
-  static __m128i EmulateVectorRotateLeftI32(void*, __m128i src1, __m128i src2) {
-    alignas(16) uint32_t value[4];
-    alignas(16) uint32_t shamt[4];
-    _mm_store_si128(reinterpret_cast<__m128i*>(value), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(shamt), src2);
-    for (size_t i = 0; i < 4; ++i) {
-      value[i] = xe::rotate_left<uint32_t>(value[i], shamt[i] & 0x1F);
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(value));
-  }
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    switch (i.instr->flags) {
-      case INT8_TYPE:
-        // TODO(benvanik): native version (with shift magic).
-        e.lea(e.r8, e.StashXmm(0, i.src1));
-        if (i.src2.is_constant) {
-          e.LoadConstantXmm(e.xmm0, i.src2.constant());
-          e.lea(e.r9, e.StashXmm(1, e.xmm0));
-        } else {
-          e.lea(e.r9, e.StashXmm(1, i.src2));
-        }
-        e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorRotateLeftI8));
-        e.vmovaps(i.dest, e.xmm0);
-        break;
-      case INT16_TYPE:
-        // TODO(benvanik): native version (with shift magic).
-        e.lea(e.r8, e.StashXmm(0, i.src1));
-        if (i.src2.is_constant) {
-          e.LoadConstantXmm(e.xmm0, i.src2.constant());
-          e.lea(e.r9, e.StashXmm(1, e.xmm0));
-        } else {
-          e.lea(e.r9, e.StashXmm(1, i.src2));
-        }
-        e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorRotateLeftI16));
-        e.vmovaps(i.dest, e.xmm0);
-        break;
-      case INT32_TYPE: {
-        if (e.IsFeatureEnabled(kX64EmitAVX2)) {
-          Xmm temp = i.dest;
-          if (i.dest == i.src1 || i.dest == i.src2) {
-            temp = e.xmm2;
-          }
-          // Shift left (to get high bits):
-          e.vpand(e.xmm0, i.src2, e.GetXmmConstPtr(XMMShiftMaskPS));
-          e.vpsllvd(e.xmm1, i.src1, e.xmm0);
-          // Shift right (to get low bits):
-          e.vmovaps(temp, e.GetXmmConstPtr(XMMPI32));
-          e.vpsubd(temp, e.xmm0);
-          e.vpsrlvd(i.dest, i.src1, temp);
-          // Merge:
-          e.vpor(i.dest, e.xmm1);
-        } else {
-          // TODO(benvanik): non-AVX2 native version.
-          e.lea(e.r8, e.StashXmm(0, i.src1));
-          if (i.src2.is_constant) {
-            e.LoadConstantXmm(e.xmm0, i.src2.constant());
-            e.lea(e.r9, e.StashXmm(1, e.xmm0));
-          } else {
-            e.lea(e.r9, e.StashXmm(1, i.src2));
-          }
-          e.CallNativeSafe(reinterpret_cast<void*>(EmulateVectorRotateLeftI32));
-          e.vmovaps(i.dest, e.xmm0);
-        }
-        break;
-      }
-      default:
-        assert_always();
-        break;
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_ROTATE_LEFT, VECTOR_ROTATE_LEFT_V128);
-
-// ============================================================================
-// OPCODE_VECTOR_AVERAGE
-// ============================================================================
-struct VECTOR_AVERAGE
-    : Sequence<VECTOR_AVERAGE,
-               I<OPCODE_VECTOR_AVERAGE, V128Op, V128Op, V128Op>> {
-  static __m128i EmulateVectorAverageUnsignedI32(void*, __m128i src1,
-                                                 __m128i src2) {
-    alignas(16) uint32_t src1v[4];
-    alignas(16) uint32_t src2v[4];
-    alignas(16) uint32_t value[4];
-    _mm_store_si128(reinterpret_cast<__m128i*>(src1v), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(src2v), src2);
-    for (size_t i = 0; i < 4; ++i) {
-      auto t = (uint64_t(src1v[i]) + uint64_t(src2v[i]) + 1) >> 1;
-      value[i] = uint32_t(t);
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(value));
-  }
-  static __m128i EmulateVectorAverageSignedI32(void*, __m128i src1,
-                                               __m128i src2) {
-    alignas(16) int32_t src1v[4];
-    alignas(16) int32_t src2v[4];
-    alignas(16) int32_t value[4];
-    _mm_store_si128(reinterpret_cast<__m128i*>(src1v), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(src2v), src2);
-    for (size_t i = 0; i < 4; ++i) {
-      auto t = (int64_t(src1v[i]) + int64_t(src2v[i]) + 1) >> 1;
-      value[i] = int32_t(t);
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(value));
-  }
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    EmitCommutativeBinaryXmmOp(
-        e, i,
-        [&i](X64Emitter& e, const Xmm& dest, const Xmm& src1, const Xmm& src2) {
-          const TypeName part_type =
-              static_cast<TypeName>(i.instr->flags & 0xFF);
-          const uint32_t arithmetic_flags = i.instr->flags >> 8;
-          bool is_unsigned = !!(arithmetic_flags & ARITHMETIC_UNSIGNED);
-          switch (part_type) {
-            case INT8_TYPE:
-              if (is_unsigned) {
-                e.vpavgb(dest, src1, src2);
-              } else {
-                assert_always();
-              }
-              break;
-            case INT16_TYPE:
-              if (is_unsigned) {
-                e.vpavgw(dest, src1, src2);
-              } else {
-                assert_always();
-              }
-              break;
-            case INT32_TYPE:
-              // No 32bit averages in AVX.
-              if (is_unsigned) {
-                if (i.src2.is_constant) {
-                  e.LoadConstantXmm(e.xmm0, i.src2.constant());
-                  e.lea(e.r9, e.StashXmm(1, e.xmm0));
-                } else {
-                  e.lea(e.r9, e.StashXmm(1, i.src2));
-                }
-                e.lea(e.r8, e.StashXmm(0, i.src1));
-                e.CallNativeSafe(
-                    reinterpret_cast<void*>(EmulateVectorAverageUnsignedI32));
-                e.vmovaps(i.dest, e.xmm0);
-              } else {
-                if (i.src2.is_constant) {
-                  e.LoadConstantXmm(e.xmm0, i.src2.constant());
-                  e.lea(e.r9, e.StashXmm(1, e.xmm0));
-                } else {
-                  e.lea(e.r9, e.StashXmm(1, i.src2));
-                }
-                e.lea(e.r8, e.StashXmm(0, i.src1));
-                e.CallNativeSafe(
-                    reinterpret_cast<void*>(EmulateVectorAverageSignedI32));
-                e.vmovaps(i.dest, e.xmm0);
-              }
-              break;
-            default:
-              assert_unhandled_case(part_type);
-              break;
-          }
-        });
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_VECTOR_AVERAGE, VECTOR_AVERAGE);
-
 // ============================================================================
 // OPCODE_BYTE_SWAP
 // ============================================================================
@@ -6497,1275 +3038,6 @@ struct CNTLZ_I64 : Sequence<CNTLZ_I64, I<OPCODE_CNTLZ, I8Op, I64Op>> {
 };
 EMITTER_OPCODE_TABLE(OPCODE_CNTLZ, CNTLZ_I8, CNTLZ_I16, CNTLZ_I32, CNTLZ_I64);
 
-// ============================================================================
-// OPCODE_INSERT
-// ============================================================================
-struct INSERT_I8
-    : Sequence<INSERT_I8, I<OPCODE_INSERT, V128Op, V128Op, I8Op, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.is_constant);
-    e.vpinsrb(i.dest, i.src3.reg().cvt32(), i.src2.constant() ^ 0x3);
-  }
-};
-struct INSERT_I16
-    : Sequence<INSERT_I16, I<OPCODE_INSERT, V128Op, V128Op, I8Op, I16Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.is_constant);
-    e.vpinsrw(i.dest, i.src3.reg().cvt32(), i.src2.constant() ^ 0x1);
-  }
-};
-struct INSERT_I32
-    : Sequence<INSERT_I32, I<OPCODE_INSERT, V128Op, V128Op, I8Op, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.is_constant);
-    e.vpinsrd(i.dest, i.src3, i.src2.constant());
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_INSERT, INSERT_I8, INSERT_I16, INSERT_I32);
-
-// ============================================================================
-// OPCODE_EXTRACT
-// ============================================================================
-// TODO(benvanik): sequence extract/splat:
-//  v0.i32 = extract v0.v128, 0
-//  v0.v128 = splat v0.i32
-// This can be a single broadcast.
-struct EXTRACT_I8
-    : Sequence<EXTRACT_I8, I<OPCODE_EXTRACT, I8Op, V128Op, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    if (i.src2.is_constant) {
-      e.vpextrb(i.dest.reg().cvt32(), i.src1, VEC128_B(i.src2.constant()));
-    } else {
-      e.mov(e.eax, 0x00000003);
-      e.xor_(e.al, i.src2);
-      e.and_(e.al, 0x1F);
-      e.vmovd(e.xmm0, e.eax);
-      e.vpshufb(e.xmm0, i.src1, e.xmm0);
-      e.vmovd(i.dest.reg().cvt32(), e.xmm0);
-      e.and_(i.dest, uint8_t(0xFF));
-    }
-  }
-};
-struct EXTRACT_I16
-    : Sequence<EXTRACT_I16, I<OPCODE_EXTRACT, I16Op, V128Op, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    if (i.src2.is_constant) {
-      e.vpextrw(i.dest.reg().cvt32(), i.src1, VEC128_W(i.src2.constant()));
-    } else {
-      e.mov(e.al, i.src2);
-      e.xor_(e.al, 0x01);
-      e.shl(e.al, 1);
-      e.mov(e.ah, e.al);
-      e.add(e.ah, 1);
-      e.vmovd(e.xmm0, e.eax);
-      e.vpshufb(e.xmm0, i.src1, e.xmm0);
-      e.vmovd(i.dest.reg().cvt32(), e.xmm0);
-      e.and_(i.dest.reg().cvt32(), 0xFFFFu);
-    }
-  }
-};
-struct EXTRACT_I32
-    : Sequence<EXTRACT_I32, I<OPCODE_EXTRACT, I32Op, V128Op, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    static const vec128_t extract_table_32[4] = {
-        vec128b(3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
-        vec128b(7, 6, 5, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
-        vec128b(11, 10, 9, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
-        vec128b(15, 14, 13, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
-    };
-    if (i.src2.is_constant) {
-      // TODO(gibbed): add support to constant propagation pass for
-      // OPCODE_EXTRACT.
-      Xmm src1;
-      if (i.src1.is_constant) {
-        src1 = e.xmm0;
-        e.LoadConstantXmm(src1, i.src1.constant());
-      } else {
-        src1 = i.src1;
-      }
-      if (i.src2.constant() == 0) {
-        e.vmovd(i.dest, src1);
-      } else {
-        e.vpextrd(i.dest, src1, VEC128_D(i.src2.constant()));
-      }
-    } else {
-      // TODO(benvanik): try out hlide's version:
-      // e.mov(e.eax, 3);
-      // e.and_(e.al, i.src2);       // eax = [(i&3), 0, 0, 0]
-      // e.imul(e.eax, 0x04040404); // [(i&3)*4, (i&3)*4, (i&3)*4, (i&3)*4]
-      // e.add(e.eax, 0x00010203);  // [((i&3)*4)+3, ((i&3)*4)+2, ((i&3)*4)+1,
-      // ((i&3)*4)+0]
-      // e.vmovd(e.xmm0, e.eax);
-      // e.vpshufb(e.xmm0, i.src1, e.xmm0);
-      // e.vmovd(i.dest.reg().cvt32(), e.xmm0);
-      // Get the desired word in xmm0, then extract that.
-      Xmm src1;
-      if (i.src1.is_constant) {
-        src1 = e.xmm1;
-        e.LoadConstantXmm(src1, i.src1.constant());
-      } else {
-        src1 = i.src1.reg();
-      }
-
-      e.xor_(e.rax, e.rax);
-      e.mov(e.al, i.src2);
-      e.and_(e.al, 0x03);
-      e.shl(e.al, 4);
-      e.mov(e.rdx, reinterpret_cast<uint64_t>(extract_table_32));
-      e.vmovaps(e.xmm0, e.ptr[e.rdx + e.rax]);
-      e.vpshufb(e.xmm0, src1, e.xmm0);
-      e.vpextrd(i.dest, e.xmm0, 0);
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_EXTRACT, EXTRACT_I8, EXTRACT_I16, EXTRACT_I32);
-
-// ============================================================================
-// OPCODE_SPLAT
-// ============================================================================
-// Copy a value into all elements of a vector
-struct SPLAT_I8 : Sequence<SPLAT_I8, I<OPCODE_SPLAT, V128Op, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    if (i.src1.is_constant) {
-      // TODO(benvanik): faster constant splats.
-      e.mov(e.eax, i.src1.constant());
-      e.vmovd(e.xmm0, e.eax);
-    } else {
-      e.vmovd(e.xmm0, i.src1.reg().cvt32());
-    }
-
-    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
-      e.vpbroadcastb(i.dest, e.xmm0);
-    } else {
-      e.vpunpcklbw(e.xmm0, e.xmm0);
-      e.vpunpcklwd(e.xmm0, e.xmm0);
-      e.vpshufd(i.dest, e.xmm0, 0);
-    }
-  }
-};
-struct SPLAT_I16 : Sequence<SPLAT_I16, I<OPCODE_SPLAT, V128Op, I16Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    if (i.src1.is_constant) {
-      // TODO(benvanik): faster constant splats.
-      e.mov(e.eax, i.src1.constant());
-      e.vmovd(e.xmm0, e.eax);
-    } else {
-      e.vmovd(e.xmm0, i.src1.reg().cvt32());
-    }
-
-    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
-      e.vpbroadcastw(i.dest, e.xmm0);
-    } else {
-      e.vpunpcklwd(e.xmm0, e.xmm0);  // unpack low word data
-      e.vpshufd(i.dest, e.xmm0, 0);
-    }
-  }
-};
-struct SPLAT_I32 : Sequence<SPLAT_I32, I<OPCODE_SPLAT, V128Op, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    if (i.src1.is_constant) {
-      // TODO(benvanik): faster constant splats.
-      e.mov(e.eax, i.src1.constant());
-      e.vmovd(e.xmm0, e.eax);
-    } else {
-      e.vmovd(e.xmm0, i.src1);
-    }
-
-    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
-      e.vpbroadcastd(i.dest, e.xmm0);
-    } else {
-      e.vpshufd(i.dest, e.xmm0, 0);
-    }
-  }
-};
-struct SPLAT_F32 : Sequence<SPLAT_F32, I<OPCODE_SPLAT, V128Op, F32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
-      if (i.src1.is_constant) {
-        // TODO(benvanik): faster constant splats.
-        e.mov(e.eax, i.src1.value->constant.i32);
-        e.vmovd(e.xmm0, e.eax);
-        e.vbroadcastss(i.dest, e.xmm0);
-      } else {
-        e.vbroadcastss(i.dest, i.src1);
-      }
-    } else {
-      if (i.src1.is_constant) {
-        e.mov(e.eax, i.src1.value->constant.i32);
-        e.vmovd(i.dest, e.eax);
-        e.vshufps(i.dest, i.dest, i.dest, 0);
-      } else {
-        e.vshufps(i.dest, i.src1, i.src1, 0);
-      }
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_SPLAT, SPLAT_I8, SPLAT_I16, SPLAT_I32, SPLAT_F32);
-
-// ============================================================================
-// OPCODE_PERMUTE
-// ============================================================================
-struct PERMUTE_I32
-    : Sequence<PERMUTE_I32, I<OPCODE_PERMUTE, V128Op, I32Op, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.instr->flags == INT32_TYPE);
-    // Permute words between src2 and src3.
-    // TODO(benvanik): check src3 for zero. if 0, we can use pshufb.
-    if (i.src1.is_constant) {
-      uint32_t control = i.src1.constant();
-      // Shuffle things into the right places in dest & xmm0,
-      // then we blend them together.
-      uint32_t src_control =
-          (((control >> 24) & 0x3) << 6) | (((control >> 16) & 0x3) << 4) |
-          (((control >> 8) & 0x3) << 2) | (((control >> 0) & 0x3) << 0);
-
-      uint32_t blend_control = 0;
-      if (e.IsFeatureEnabled(kX64EmitAVX2)) {
-        // Blender for vpblendd
-        blend_control =
-            (((control >> 26) & 0x1) << 3) | (((control >> 18) & 0x1) << 2) |
-            (((control >> 10) & 0x1) << 1) | (((control >> 2) & 0x1) << 0);
-      } else {
-        // Blender for vpblendw
-        blend_control =
-            (((control >> 26) & 0x1) << 6) | (((control >> 18) & 0x1) << 4) |
-            (((control >> 10) & 0x1) << 2) | (((control >> 2) & 0x1) << 0);
-        blend_control |= blend_control << 1;
-      }
-
-      // TODO(benvanik): if src2/src3 are constants, shuffle now!
-      Xmm src2;
-      if (i.src2.is_constant) {
-        src2 = e.xmm1;
-        e.LoadConstantXmm(src2, i.src2.constant());
-      } else {
-        src2 = i.src2;
-      }
-      Xmm src3;
-      if (i.src3.is_constant) {
-        src3 = e.xmm2;
-        e.LoadConstantXmm(src3, i.src3.constant());
-      } else {
-        src3 = i.src3;
-      }
-      if (i.dest != src3) {
-        e.vpshufd(i.dest, src2, src_control);
-        e.vpshufd(e.xmm0, src3, src_control);
-      } else {
-        e.vmovaps(e.xmm0, src3);
-        e.vpshufd(i.dest, src2, src_control);
-        e.vpshufd(e.xmm0, e.xmm0, src_control);
-      }
-
-      if (e.IsFeatureEnabled(kX64EmitAVX2)) {
-        e.vpblendd(i.dest, e.xmm0, blend_control);  // $0 = $1 <blend> $2
-      } else {
-        e.vpblendw(i.dest, e.xmm0, blend_control);  // $0 = $1 <blend> $2
-      }
-    } else {
-      // Permute by non-constant.
-      assert_always();
-    }
-  }
-};
-struct PERMUTE_V128
-    : Sequence<PERMUTE_V128,
-               I<OPCODE_PERMUTE, V128Op, V128Op, V128Op, V128Op>> {
-  static void EmitByInt8(X64Emitter& e, const EmitArgType& i) {
-    // TODO(benvanik): find out how to do this with only one temp register!
-    // Permute bytes between src2 and src3.
-    // src1 is an array of indices corresponding to positions within src2 and
-    // src3.
-    if (i.src3.value->IsConstantZero()) {
-      // Permuting with src2/zero, so just shuffle/mask.
-      if (i.src2.value->IsConstantZero()) {
-        // src2 & src3 are zero, so result will always be zero.
-        e.vpxor(i.dest, i.dest);
-      } else {
-        // Control mask needs to be shuffled.
-        if (i.src1.is_constant) {
-          e.LoadConstantXmm(e.xmm0, i.src1.constant());
-          e.vxorps(e.xmm0, e.xmm0, e.GetXmmConstPtr(XMMSwapWordMask));
-        } else {
-          e.vxorps(e.xmm0, i.src1, e.GetXmmConstPtr(XMMSwapWordMask));
-        }
-        e.vpand(e.xmm0, e.GetXmmConstPtr(XMMPermuteByteMask));
-        if (i.src2.is_constant) {
-          e.LoadConstantXmm(i.dest, i.src2.constant());
-          e.vpshufb(i.dest, i.dest, e.xmm0);
-        } else {
-          e.vpshufb(i.dest, i.src2, e.xmm0);
-        }
-        // Build a mask with values in src2 having 0 and values in src3 having
-        // 1.
-        e.vpcmpgtb(e.xmm0, e.xmm0, e.GetXmmConstPtr(XMMPermuteControl15));
-        e.vpandn(i.dest, e.xmm0, i.dest);
-      }
-    } else {
-      // General permute.
-      // Control mask needs to be shuffled.
-      // TODO(benvanik): do constants here instead of in generated code.
-      if (i.src1.is_constant) {
-        e.LoadConstantXmm(e.xmm2, i.src1.constant());
-        e.vxorps(e.xmm2, e.xmm2, e.GetXmmConstPtr(XMMSwapWordMask));
-      } else {
-        e.vxorps(e.xmm2, i.src1, e.GetXmmConstPtr(XMMSwapWordMask));
-      }
-      e.vpand(e.xmm2, e.GetXmmConstPtr(XMMPermuteByteMask));
-      Xmm src2_shuf = e.xmm0;
-      if (i.src2.value->IsConstantZero()) {
-        e.vpxor(src2_shuf, src2_shuf);
-      } else if (i.src2.is_constant) {
-        e.LoadConstantXmm(src2_shuf, i.src2.constant());
-        e.vpshufb(src2_shuf, src2_shuf, e.xmm2);
-      } else {
-        e.vpshufb(src2_shuf, i.src2, e.xmm2);
-      }
-      Xmm src3_shuf = e.xmm1;
-      if (i.src3.value->IsConstantZero()) {
-        e.vpxor(src3_shuf, src3_shuf);
-      } else if (i.src3.is_constant) {
-        e.LoadConstantXmm(src3_shuf, i.src3.constant());
-        e.vpshufb(src3_shuf, src3_shuf, e.xmm2);
-      } else {
-        e.vpshufb(src3_shuf, i.src3, e.xmm2);
-      }
-      // Build a mask with values in src2 having 0 and values in src3 having 1.
-      e.vpcmpgtb(i.dest, e.xmm2, e.GetXmmConstPtr(XMMPermuteControl15));
-      e.vpblendvb(i.dest, src2_shuf, src3_shuf, i.dest);
-    }
-  }
-
-  static void EmitByInt16(X64Emitter& e, const EmitArgType& i) {
-    // src1 is an array of indices corresponding to positions within src2 and
-    // src3.
-    assert_true(i.src1.is_constant);
-    vec128_t perm = (i.src1.constant() & vec128s(0xF)) ^ vec128s(0x1);
-    vec128_t perm_ctrl = vec128b(0);
-    for (int i = 0; i < 8; i++) {
-      perm_ctrl.i16[i] = perm.i16[i] > 7 ? -1 : 0;
-
-      auto v = uint8_t(perm.u16[i]);
-      perm.u8[i * 2] = v * 2;
-      perm.u8[i * 2 + 1] = v * 2 + 1;
-    }
-    e.LoadConstantXmm(e.xmm0, perm);
-
-    if (i.src2.is_constant) {
-      e.LoadConstantXmm(e.xmm1, i.src2.constant());
-    } else {
-      e.vmovdqa(e.xmm1, i.src2);
-    }
-    if (i.src3.is_constant) {
-      e.LoadConstantXmm(e.xmm2, i.src3.constant());
-    } else {
-      e.vmovdqa(e.xmm2, i.src3);
-    }
-
-    e.vpshufb(e.xmm1, e.xmm1, e.xmm0);
-    e.vpshufb(e.xmm2, e.xmm2, e.xmm0);
-
-    uint8_t mask = 0;
-    for (int i = 0; i < 8; i++) {
-      if (perm_ctrl.i16[i] == 0) {
-        mask |= 1 << (7 - i);
-      }
-    }
-    e.vpblendw(i.dest, e.xmm1, e.xmm2, mask);
-  }
-
-  static void EmitByInt32(X64Emitter& e, const EmitArgType& i) {
-    assert_always();
-  }
-
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    switch (i.instr->flags) {
-      case INT8_TYPE:
-        EmitByInt8(e, i);
-        break;
-      case INT16_TYPE:
-        EmitByInt16(e, i);
-        break;
-      case INT32_TYPE:
-        EmitByInt32(e, i);
-        break;
-      default:
-        assert_unhandled_case(i.instr->flags);
-        return;
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_PERMUTE, PERMUTE_I32, PERMUTE_V128);
-
-// ============================================================================
-// OPCODE_SWIZZLE
-// ============================================================================
-struct SWIZZLE
-    : Sequence<SWIZZLE, I<OPCODE_SWIZZLE, V128Op, V128Op, OffsetOp>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    auto element_type = i.instr->flags;
-    if (element_type == INT8_TYPE) {
-      assert_always();
-    } else if (element_type == INT16_TYPE) {
-      assert_always();
-    } else if (element_type == INT32_TYPE || element_type == FLOAT32_TYPE) {
-      uint8_t swizzle_mask = static_cast<uint8_t>(i.src2.value);
-      Xmm src1;
-      if (i.src1.is_constant) {
-        src1 = e.xmm0;
-        e.LoadConstantXmm(src1, i.src1.constant());
-      } else {
-        src1 = i.src1;
-      }
-      e.vpshufd(i.dest, src1, swizzle_mask);
-    } else if (element_type == INT64_TYPE || element_type == FLOAT64_TYPE) {
-      assert_always();
-    } else {
-      assert_always();
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_SWIZZLE, SWIZZLE);
-
-// ============================================================================
-// OPCODE_PACK
-// ============================================================================
-struct PACK : Sequence<PACK, I<OPCODE_PACK, V128Op, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    switch (i.instr->flags & PACK_TYPE_MODE) {
-      case PACK_TYPE_D3DCOLOR:
-        EmitD3DCOLOR(e, i);
-        break;
-      case PACK_TYPE_FLOAT16_2:
-        EmitFLOAT16_2(e, i);
-        break;
-      case PACK_TYPE_FLOAT16_4:
-        EmitFLOAT16_4(e, i);
-        break;
-      case PACK_TYPE_SHORT_2:
-        EmitSHORT_2(e, i);
-        break;
-      case PACK_TYPE_SHORT_4:
-        EmitSHORT_4(e, i);
-        break;
-      case PACK_TYPE_UINT_2101010:
-        EmitUINT_2101010(e, i);
-        break;
-      case PACK_TYPE_8_IN_16:
-        Emit8_IN_16(e, i, i.instr->flags);
-        break;
-      case PACK_TYPE_16_IN_32:
-        Emit16_IN_32(e, i, i.instr->flags);
-        break;
-      default:
-        assert_unhandled_case(i.instr->flags);
-        break;
-    }
-  }
-  static void EmitD3DCOLOR(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.value->IsConstantZero());
-    Xmm src;
-    if (i.src1.is_constant) {
-      src = i.dest;
-      e.LoadConstantXmm(src, i.src1.constant());
-    } else {
-      src = i.src1;
-    }
-    // Saturate to [3,3....] so that only values between 3...[00] and 3...[FF]
-    // are valid.
-    e.vminps(i.dest, src, e.GetXmmConstPtr(XMMPackD3DCOLORSat));
-    e.vmaxps(i.dest, i.dest, e.GetXmmConstPtr(XMM3333));
-    // Extract bytes.
-    // RGBA (XYZW) -> ARGB (WXYZ)
-    // w = ((src1.uw & 0xFF) << 24) | ((src1.ux & 0xFF) << 16) |
-    //     ((src1.uy & 0xFF) << 8) | (src1.uz & 0xFF)
-    e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMPackD3DCOLOR));
-  }
-  static __m128i EmulateFLOAT16_2(void*, __m128 src1) {
-    alignas(16) float a[4];
-    alignas(16) uint16_t b[8];
-    _mm_store_ps(a, src1);
-    std::memset(b, 0, sizeof(b));
-
-    for (int i = 0; i < 2; i++) {
-      b[7 - i] = half_float::detail::float2half<std::round_toward_zero>(a[i]);
-    }
-
-    return _mm_load_si128(reinterpret_cast<__m128i*>(b));
-  }
-  static void EmitFLOAT16_2(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.value->IsConstantZero());
-    // http://blogs.msdn.com/b/chuckw/archive/2012/09/11/directxmath-f16c-and-fma.aspx
-    // dest = [(src1.x | src1.y), 0, 0, 0]
-
-    Xmm src;
-    if (e.IsFeatureEnabled(kX64EmitF16C)) {
-      if (i.src1.is_constant) {
-        src = i.dest;
-        e.LoadConstantXmm(src, i.src1.constant());
-      } else {
-        src = i.src1;
-      }
-      // 0|0|0|0|W|Z|Y|X
-      e.vcvtps2ph(i.dest, src, 0b00000011);
-      // Shuffle to X|Y|0|0|0|0|0|0
-      e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMPackFLOAT16_2));
-    } else {
-      if (i.src1.is_constant) {
-        src = e.xmm0;
-        e.LoadConstantXmm(src, i.src1.constant());
-      } else {
-        src = i.src1;
-      }
-      e.lea(e.r8, e.StashXmm(0, src));
-      e.CallNativeSafe(reinterpret_cast<void*>(EmulateFLOAT16_2));
-      e.vmovaps(i.dest, e.xmm0);
-    }
-  }
-  static __m128i EmulateFLOAT16_4(void*, __m128 src1) {
-    alignas(16) float a[4];
-    alignas(16) uint16_t b[8];
-    _mm_store_ps(a, src1);
-    std::memset(b, 0, sizeof(b));
-
-    for (int i = 0; i < 4; i++) {
-      b[7 - i] = half_float::detail::float2half<std::round_toward_zero>(a[i]);
-    }
-
-    return _mm_load_si128(reinterpret_cast<__m128i*>(b));
-  }
-  static void EmitFLOAT16_4(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.value->IsConstantZero());
-    // dest = [(src1.x | src1.y), (src1.z | src1.w), 0, 0]
-
-    Xmm src;
-    if (e.IsFeatureEnabled(kX64EmitF16C)) {
-      if (i.src1.is_constant) {
-        src = i.dest;
-        e.LoadConstantXmm(src, i.src1.constant());
-      } else {
-        src = i.src1;
-      }
-      // 0|0|0|0|W|Z|Y|X
-      e.vcvtps2ph(i.dest, src, 0b00000011);
-      // Shuffle to X|Y|Z|W|0|0|0|0
-      e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMPackFLOAT16_4));
-    } else {
-      if (i.src1.is_constant) {
-        src = e.xmm0;
-        e.LoadConstantXmm(src, i.src1.constant());
-      } else {
-        src = i.src1;
-      }
-      e.lea(e.r8, e.StashXmm(0, src));
-      e.CallNativeSafe(reinterpret_cast<void*>(EmulateFLOAT16_4));
-      e.vmovaps(i.dest, e.xmm0);
-    }
-  }
-  static void EmitSHORT_2(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.value->IsConstantZero());
-    Xmm src;
-    if (i.src1.is_constant) {
-      src = i.dest;
-      e.LoadConstantXmm(src, i.src1.constant());
-    } else {
-      src = i.src1;
-    }
-    // Saturate.
-    e.vmaxps(i.dest, src, e.GetXmmConstPtr(XMMPackSHORT_Min));
-    e.vminps(i.dest, i.dest, e.GetXmmConstPtr(XMMPackSHORT_Max));
-    // Pack.
-    e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMPackSHORT_2));
-  }
-  static void EmitSHORT_4(X64Emitter& e, const EmitArgType& i) {
-    assert_true(i.src2.value->IsConstantZero());
-    Xmm src;
-    if (i.src1.is_constant) {
-      src = i.dest;
-      e.LoadConstantXmm(src, i.src1.constant());
-    } else {
-      src = i.src1;
-    }
-    // Saturate.
-    e.vmaxps(i.dest, src, e.GetXmmConstPtr(XMMPackSHORT_Min));
-    e.vminps(i.dest, i.dest, e.GetXmmConstPtr(XMMPackSHORT_Max));
-    // Pack.
-    e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMPackSHORT_4));
-  }
-  static void EmitUINT_2101010(X64Emitter& e, const EmitArgType& i) {
-    // https://www.opengl.org/registry/specs/ARB/vertex_type_2_10_10_10_rev.txt
-    // XYZ are 10 bits, signed and saturated.
-    // W is 2 bits, unsigned and saturated.
-    Xmm src;
-    if (i.src1.is_constant) {
-      src = i.dest;
-      e.LoadConstantXmm(src, i.src1.constant());
-    } else {
-      src = i.src1;
-    }
-    // Saturate.
-    e.vmaxps(i.dest, src, e.GetXmmConstPtr(XMMPackUINT_2101010_MinUnpacked));
-    e.vminps(i.dest, i.dest, e.GetXmmConstPtr(XMMPackUINT_2101010_MaxUnpacked));
-    // Remove the unneeded bits of the floats.
-    e.vpand(i.dest, e.GetXmmConstPtr(XMMPackUINT_2101010_MaskUnpacked));
-    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
-      // Shift the components up.
-      e.vpsllvd(i.dest, i.dest, e.GetXmmConstPtr(XMMPackUINT_2101010_Shift));
-    } else {
-      // Duplicate all the components into bits 10-19.
-      e.vpslld(e.xmm0, i.dest, 10);
-      e.vpor(i.dest, e.xmm0);
-      // Duplicate all the components into bits 20-39
-      // (so alpha will be in 30-31).
-      e.vpslld(e.xmm0, i.dest, 20);
-      e.vpor(i.dest, e.xmm0);
-      // Leave only the needed components.
-      e.vpand(i.dest, e.GetXmmConstPtr(XMMPackUINT_2101010_MaskPacked));
-    }
-    // Combine the components.
-    e.vshufps(e.xmm0, i.dest, i.dest, _MM_SHUFFLE(2, 3, 0, 1));
-    e.vorps(i.dest, e.xmm0);
-    e.vshufps(e.xmm0, i.dest, i.dest, _MM_SHUFFLE(1, 0, 3, 2));
-    e.vorps(i.dest, e.xmm0);
-  }
-  static __m128i EmulatePack8_IN_16_UN_UN_SAT(void*, __m128i src1,
-                                              __m128i src2) {
-    alignas(16) uint16_t a[8];
-    alignas(16) uint16_t b[8];
-    alignas(16) uint8_t c[16];
-    _mm_store_si128(reinterpret_cast<__m128i*>(a), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(b), src2);
-    for (int i = 0; i < 8; ++i) {
-      c[i] = uint8_t(std::max(uint16_t(0), std::min(uint16_t(255), a[i])));
-      c[i + 8] = uint8_t(std::max(uint16_t(0), std::min(uint16_t(255), b[i])));
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(c));
-  }
-  static __m128i EmulatePack8_IN_16_UN_UN(void*, __m128i src1, __m128i src2) {
-    alignas(16) uint8_t a[16];
-    alignas(16) uint8_t b[16];
-    alignas(16) uint8_t c[16];
-    _mm_store_si128(reinterpret_cast<__m128i*>(a), src1);
-    _mm_store_si128(reinterpret_cast<__m128i*>(b), src2);
-    for (int i = 0; i < 8; ++i) {
-      c[i] = a[i * 2];
-      c[i + 8] = b[i * 2];
-    }
-    return _mm_load_si128(reinterpret_cast<__m128i*>(c));
-  }
-  static void Emit8_IN_16(X64Emitter& e, const EmitArgType& i, uint32_t flags) {
-    // TODO(benvanik): handle src2 (or src1) being constant zero
-    if (IsPackInUnsigned(flags)) {
-      if (IsPackOutUnsigned(flags)) {
-        if (IsPackOutSaturate(flags)) {
-          // unsigned -> unsigned + saturate
-          if (i.src2.is_constant) {
-            e.LoadConstantXmm(e.xmm0, i.src2.constant());
-            e.lea(e.r9, e.StashXmm(1, e.xmm0));
-          } else {
-            e.lea(e.r9, e.StashXmm(1, i.src2));
-          }
-          e.lea(e.r8, e.StashXmm(0, i.src1));
-          e.CallNativeSafe(
-              reinterpret_cast<void*>(EmulatePack8_IN_16_UN_UN_SAT));
-          e.vmovaps(i.dest, e.xmm0);
-          e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMByteOrderMask));
-        } else {
-          // unsigned -> unsigned
-          e.lea(e.r9, e.StashXmm(1, i.src2));
-          e.lea(e.r8, e.StashXmm(0, i.src1));
-          e.CallNativeSafe(reinterpret_cast<void*>(EmulatePack8_IN_16_UN_UN));
-          e.vmovaps(i.dest, e.xmm0);
-          e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMByteOrderMask));
-        }
-      } else {
-        if (IsPackOutSaturate(flags)) {
-          // unsigned -> signed + saturate
-          assert_always();
-        } else {
-          // unsigned -> signed
-          assert_always();
-        }
-      }
-    } else {
-      if (IsPackOutUnsigned(flags)) {
-        if (IsPackOutSaturate(flags)) {
-          // signed -> unsigned + saturate
-          // PACKUSWB / SaturateSignedWordToUnsignedByte
-          Xbyak::Xmm src2 = i.src2.is_constant ? e.xmm0 : i.src2;
-          if (i.src2.is_constant) {
-            e.LoadConstantXmm(src2, i.src2.constant());
-          }
-
-          e.vpackuswb(i.dest, i.src1, src2);
-          e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMByteOrderMask));
-        } else {
-          // signed -> unsigned
-          assert_always();
-        }
-      } else {
-        if (IsPackOutSaturate(flags)) {
-          // signed -> signed + saturate
-          // PACKSSWB / SaturateSignedWordToSignedByte
-          e.vpacksswb(i.dest, i.src1, i.src2);
-          e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMByteOrderMask));
-        } else {
-          // signed -> signed
-          assert_always();
-        }
-      }
-    }
-  }
-  // Pack 2 32-bit vectors into a 16-bit vector.
-  static void Emit16_IN_32(X64Emitter& e, const EmitArgType& i,
-                           uint32_t flags) {
-    // TODO(benvanik): handle src2 (or src1) being constant zero
-    if (IsPackInUnsigned(flags)) {
-      if (IsPackOutUnsigned(flags)) {
-        if (IsPackOutSaturate(flags)) {
-          // unsigned -> unsigned + saturate
-          // Construct a saturation max value
-          e.mov(e.eax, 0xFFFFu);
-          e.vmovd(e.xmm0, e.eax);
-          e.vpshufd(e.xmm0, e.xmm0, 0b00000000);
-
-          if (!i.src1.is_constant) {
-            e.vpminud(e.xmm1, i.src1, e.xmm0);  // Saturate src1
-            e.vpshuflw(e.xmm1, e.xmm1, 0b00100010);
-            e.vpshufhw(e.xmm1, e.xmm1, 0b00100010);
-            e.vpshufd(e.xmm1, e.xmm1, 0b00001000);
-          } else {
-            // TODO(DrChat): Non-zero constants
-            assert_true(i.src1.constant().u64[0] == 0 &&
-                        i.src1.constant().u64[1] == 0);
-            e.vpxor(e.xmm1, e.xmm1);
-          }
-
-          if (!i.src2.is_constant) {
-            e.vpminud(i.dest, i.src2, e.xmm0);  // Saturate src2
-            e.vpshuflw(i.dest, i.dest, 0b00100010);
-            e.vpshufhw(i.dest, i.dest, 0b00100010);
-            e.vpshufd(i.dest, i.dest, 0b10000000);
-          } else {
-            // TODO(DrChat): Non-zero constants
-            assert_true(i.src2.constant().u64[0] == 0 &&
-                        i.src2.constant().u64[1] == 0);
-            e.vpxor(i.dest, i.dest);
-          }
-
-          e.vpblendw(i.dest, i.dest, e.xmm1, 0b00001111);
-        } else {
-          // unsigned -> unsigned
-          e.vmovaps(e.xmm0, i.src1);
-          e.vpshuflw(e.xmm0, e.xmm0, 0b00100010);
-          e.vpshufhw(e.xmm0, e.xmm0, 0b00100010);
-          e.vpshufd(e.xmm0, e.xmm0, 0b00001000);
-
-          e.vmovaps(i.dest, i.src2);
-          e.vpshuflw(i.dest, i.dest, 0b00100010);
-          e.vpshufhw(i.dest, i.dest, 0b00100010);
-          e.vpshufd(i.dest, i.dest, 0b10000000);
-
-          e.vpblendw(i.dest, i.dest, e.xmm0, 0b00001111);
-        }
-      } else {
-        if (IsPackOutSaturate(flags)) {
-          // unsigned -> signed + saturate
-          assert_always();
-        } else {
-          // unsigned -> signed
-          assert_always();
-        }
-      }
-    } else {
-      if (IsPackOutUnsigned(flags)) {
-        if (IsPackOutSaturate(flags)) {
-          // signed -> unsigned + saturate
-          // PACKUSDW
-          // TMP[15:0] <- (DEST[31:0] < 0) ? 0 : DEST[15:0];
-          // DEST[15:0] <- (DEST[31:0] > FFFFH) ? FFFFH : TMP[15:0];
-          e.vpackusdw(i.dest, i.src1, i.src2);
-          e.vpshuflw(i.dest, i.dest, 0b10110001);
-          e.vpshufhw(i.dest, i.dest, 0b10110001);
-        } else {
-          // signed -> unsigned
-          assert_always();
-        }
-      } else {
-        if (IsPackOutSaturate(flags)) {
-          // signed -> signed + saturate
-          // PACKSSDW / SaturateSignedDwordToSignedWord
-          Xmm src2;
-          if (!i.src2.is_constant) {
-            src2 = i.src2;
-          } else {
-            assert_false(i.src1 == e.xmm0);
-            src2 = e.xmm0;
-            e.LoadConstantXmm(src2, i.src2.constant());
-          }
-          e.vpackssdw(i.dest, i.src1, src2);
-          e.vpshuflw(i.dest, i.dest, 0b10110001);
-          e.vpshufhw(i.dest, i.dest, 0b10110001);
-        } else {
-          // signed -> signed
-          assert_always();
-        }
-      }
-    }
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_PACK, PACK);
-
-// ============================================================================
-// OPCODE_UNPACK
-// ============================================================================
-struct UNPACK : Sequence<UNPACK, I<OPCODE_UNPACK, V128Op, V128Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    switch (i.instr->flags & PACK_TYPE_MODE) {
-      case PACK_TYPE_D3DCOLOR:
-        EmitD3DCOLOR(e, i);
-        break;
-      case PACK_TYPE_FLOAT16_2:
-        EmitFLOAT16_2(e, i);
-        break;
-      case PACK_TYPE_FLOAT16_4:
-        EmitFLOAT16_4(e, i);
-        break;
-      case PACK_TYPE_SHORT_2:
-        EmitSHORT_2(e, i);
-        break;
-      case PACK_TYPE_SHORT_4:
-        EmitSHORT_4(e, i);
-        break;
-      case PACK_TYPE_UINT_2101010:
-        EmitUINT_2101010(e, i);
-        break;
-      case PACK_TYPE_8_IN_16:
-        Emit8_IN_16(e, i, i.instr->flags);
-        break;
-      case PACK_TYPE_16_IN_32:
-        Emit16_IN_32(e, i, i.instr->flags);
-        break;
-      default:
-        assert_unhandled_case(i.instr->flags);
-        break;
-    }
-  }
-  static void EmitD3DCOLOR(X64Emitter& e, const EmitArgType& i) {
-    // ARGB (WXYZ) -> RGBA (XYZW)
-    Xmm src;
-    if (i.src1.is_constant) {
-      if (i.src1.value->IsConstantZero()) {
-        e.vmovaps(i.dest, e.GetXmmConstPtr(XMMOne));
-        return;
-      }
-      src = i.dest;
-      e.LoadConstantXmm(src, i.src1.constant());
-    } else {
-      src = i.src1;
-    }
-    // src = ZZYYXXWW
-    // Unpack to 000000ZZ,000000YY,000000XX,000000WW
-    e.vpshufb(i.dest, src, e.GetXmmConstPtr(XMMUnpackD3DCOLOR));
-    // Add 1.0f to each.
-    e.vpor(i.dest, e.GetXmmConstPtr(XMMOne));
-    // To convert to 0 to 1, games multiply by 0x47008081 and add 0xC7008081.
-  }
-  static __m128 EmulateFLOAT16_2(void*, __m128i src1) {
-    alignas(16) uint16_t a[8];
-    alignas(16) float b[4];
-    _mm_store_si128(reinterpret_cast<__m128i*>(a), src1);
-
-    for (int i = 0; i < 2; i++) {
-      b[i] = half_float::detail::half2float(a[VEC128_W(6 + i)]);
-    }
-
-    // Constants, or something
-    b[2] = 0.f;
-    b[3] = 1.f;
-
-    return _mm_load_ps(b);
-  }
-  static void EmitFLOAT16_2(X64Emitter& e, const EmitArgType& i) {
-    // 1 bit sign, 5 bit exponent, 10 bit mantissa
-    // D3D10 half float format
-    // TODO(benvanik):
-    // http://blogs.msdn.com/b/chuckw/archive/2012/09/11/directxmath-f16c-and-fma.aspx
-    // Use _mm_cvtph_ps -- requires very modern processors (SSE5+)
-    // Unpacking half floats:
-    // http://fgiesen.wordpress.com/2012/03/28/half-to-float-done-quic/
-    // Packing half floats: https://gist.github.com/rygorous/2156668
-    // Load source, move from tight pack of X16Y16.... to X16...Y16...
-    // Also zero out the high end.
-    // TODO(benvanik): special case constant unpacks that just get 0/1/etc.
-
-    Xmm src;
-    if (e.IsFeatureEnabled(kX64EmitF16C)) {
-      if (i.src1.is_constant) {
-        src = i.dest;
-        e.LoadConstantXmm(src, i.src1.constant());
-      } else {
-        src = i.src1;
-      }
-      // sx = src.iw >> 16;
-      // sy = src.iw & 0xFFFF;
-      // dest = { XMConvertHalfToFloat(sx),
-      //          XMConvertHalfToFloat(sy),
-      //          0.0,
-      //          1.0 };
-      // Shuffle to 0|0|0|0|0|0|Y|X
-      e.vpshufb(i.dest, src, e.GetXmmConstPtr(XMMUnpackFLOAT16_2));
-      e.vcvtph2ps(i.dest, i.dest);
-      e.vpshufd(i.dest, i.dest, 0b10100100);
-      e.vpor(i.dest, e.GetXmmConstPtr(XMM0001));
-    } else {
-      if (i.src1.is_constant) {
-        src = e.xmm0;
-        e.LoadConstantXmm(src, i.src1.constant());
-      } else {
-        src = i.src1;
-      }
-      e.lea(e.r8, e.StashXmm(0, src));
-      e.CallNativeSafe(reinterpret_cast<void*>(EmulateFLOAT16_2));
-      e.vmovaps(i.dest, e.xmm0);
-    }
-  }
-  static __m128 EmulateFLOAT16_4(void*, __m128i src1) {
-    alignas(16) uint16_t a[8];
-    alignas(16) float b[4];
-    _mm_store_si128(reinterpret_cast<__m128i*>(a), src1);
-
-    for (int i = 0; i < 4; i++) {
-      b[i] = half_float::detail::half2float(a[VEC128_W(4 + i)]);
-    }
-
-    return _mm_load_ps(b);
-  }
-  static void EmitFLOAT16_4(X64Emitter& e, const EmitArgType& i) {
-    // src = [(dest.x | dest.y), (dest.z | dest.w), 0, 0]
-    Xmm src;
-    if (e.IsFeatureEnabled(kX64EmitF16C)) {
-      if (i.src1.is_constant) {
-        src = i.dest;
-        e.LoadConstantXmm(src, i.src1.constant());
-      } else {
-        src = i.src1;
-      }
-      // Shuffle to 0|0|0|0|W|Z|Y|X
-      e.vpshufb(i.dest, src, e.GetXmmConstPtr(XMMUnpackFLOAT16_4));
-      e.vcvtph2ps(i.dest, i.dest);
-    } else {
-      if (i.src1.is_constant) {
-        src = e.xmm0;
-        e.LoadConstantXmm(src, i.src1.constant());
-      } else {
-        src = i.src1;
-      }
-      e.lea(e.r8, e.StashXmm(0, src));
-      e.CallNativeSafe(reinterpret_cast<void*>(EmulateFLOAT16_4));
-      e.vmovaps(i.dest, e.xmm0);
-    }
-  }
-  static void EmitSHORT_2(X64Emitter& e, const EmitArgType& i) {
-    // (VD.x) = 3.0 + (VB.x>>16)*2^-22
-    // (VD.y) = 3.0 + (VB.x)*2^-22
-    // (VD.z) = 0.0
-    // (VD.w) = 1.0 (games splat W after unpacking to get vectors of 1.0f)
-    // src is (xx,xx,xx,VALUE)
-    Xmm src;
-    if (i.src1.is_constant) {
-      if (i.src1.value->IsConstantZero()) {
-        e.vmovdqa(i.dest, e.GetXmmConstPtr(XMM3301));
-        return;
-      }
-      // TODO(benvanik): check other common constants/perform shuffle/or here.
-      src = i.dest;
-      e.LoadConstantXmm(src, i.src1.constant());
-    } else {
-      src = i.src1;
-    }
-    // Shuffle bytes.
-    e.vpshufb(i.dest, src, e.GetXmmConstPtr(XMMUnpackSHORT_2));
-    // If negative, make smaller than 3 - sign extend before adding.
-    e.vpslld(i.dest, 16);
-    e.vpsrad(i.dest, 16);
-    // Add 3,3,0,1.
-    e.vpaddd(i.dest, e.GetXmmConstPtr(XMM3301));
-    // Return quiet NaNs in case of negative overflow.
-    e.vcmpeqps(e.xmm0, i.dest, e.GetXmmConstPtr(XMMUnpackSHORT_Overflow));
-    e.vblendvps(i.dest, i.dest, e.GetXmmConstPtr(XMMUnpackOverflowNaN), e.xmm0);
-  }
-  static void EmitSHORT_4(X64Emitter& e, const EmitArgType& i) {
-    // (VD.x) = 3.0 + (VB.x>>16)*2^-22
-    // (VD.y) = 3.0 + (VB.x)*2^-22
-    // (VD.z) = 3.0 + (VB.y>>16)*2^-22
-    // (VD.w) = 3.0 + (VB.y)*2^-22
-    // src is (xx,xx,VALUE,VALUE)
-    Xmm src;
-    if (i.src1.is_constant) {
-      if (i.src1.value->IsConstantZero()) {
-        e.vmovdqa(i.dest, e.GetXmmConstPtr(XMM3333));
-        return;
-      }
-      // TODO(benvanik): check other common constants/perform shuffle/or here.
-      src = i.dest;
-      e.LoadConstantXmm(src, i.src1.constant());
-    } else {
-      src = i.src1;
-    }
-    // Shuffle bytes.
-    e.vpshufb(i.dest, src, e.GetXmmConstPtr(XMMUnpackSHORT_4));
-    // If negative, make smaller than 3 - sign extend before adding.
-    e.vpslld(i.dest, 16);
-    e.vpsrad(i.dest, 16);
-    // Add 3,3,3,3.
-    e.vpaddd(i.dest, e.GetXmmConstPtr(XMM3333));
-    // Return quiet NaNs in case of negative overflow.
-    e.vcmpeqps(e.xmm0, i.dest, e.GetXmmConstPtr(XMMUnpackSHORT_Overflow));
-    e.vblendvps(i.dest, i.dest, e.GetXmmConstPtr(XMMUnpackOverflowNaN), e.xmm0);
-  }
-  static void EmitUINT_2101010(X64Emitter& e, const EmitArgType& i) {
-    Xmm src;
-    if (i.src1.is_constant) {
-      if (i.src1.value->IsConstantZero()) {
-        e.vmovdqa(i.dest, e.GetXmmConstPtr(XMM3331));
-        return;
-      }
-      src = i.dest;
-      e.LoadConstantXmm(src, i.src1.constant());
-    } else {
-      src = i.src1;
-    }
-    // Splat W.
-    e.vshufps(i.dest, src, src, _MM_SHUFFLE(3, 3, 3, 3));
-    // Keep only the needed components.
-    // Red in 0-9 now, green in 10-19, blue in 20-29, alpha in 30-31.
-    e.vpand(i.dest, e.GetXmmConstPtr(XMMPackUINT_2101010_MaskPacked));
-    if (e.IsFeatureEnabled(kX64EmitAVX2)) {
-      // Shift the components down.
-      e.vpsrlvd(i.dest, i.dest, e.GetXmmConstPtr(XMMPackUINT_2101010_Shift));
-    } else {
-      // Duplicate green in 0-9 and alpha in 20-21.
-      e.vpsrld(e.xmm0, i.dest, 10);
-      e.vpor(i.dest, e.xmm0);
-      // Duplicate blue in 0-9 and alpha in 0-1.
-      e.vpsrld(e.xmm0, i.dest, 20);
-      e.vpor(i.dest, e.xmm0);
-      // Remove higher duplicate components.
-      e.vpand(i.dest, e.GetXmmConstPtr(XMMPackUINT_2101010_MaskUnpacked));
-    }
-    // If XYZ are negative, make smaller than 3 - sign extend XYZ before adding.
-    // W is unsigned.
-    e.vpslld(i.dest, 22);
-    e.vpsrad(i.dest, 22);
-    // Add 3,3,3,1.
-    e.vpaddd(i.dest, e.GetXmmConstPtr(XMM3331));
-    // Return quiet NaNs in case of negative overflow.
-    e.vcmpeqps(e.xmm0, i.dest,
-               e.GetXmmConstPtr(XMMUnpackUINT_2101010_Overflow));
-    e.vblendvps(i.dest, i.dest, e.GetXmmConstPtr(XMMUnpackOverflowNaN), e.xmm0);
-    // To convert XYZ to -1 to 1, games multiply by 0x46004020 & sub 0x46C06030.
-    // For W to 0 to 1, they multiply by and subtract 0x4A2AAAAB.
-  }
-  static void Emit8_IN_16(X64Emitter& e, const EmitArgType& i, uint32_t flags) {
-    assert_false(IsPackOutSaturate(flags));
-    Xmm src;
-    if (i.src1.is_constant) {
-      src = i.dest;
-      e.LoadConstantXmm(src, i.src1.constant());
-    } else {
-      src = i.src1;
-    }
-    if (IsPackToLo(flags)) {
-      // Unpack to LO.
-      if (IsPackInUnsigned(flags)) {
-        if (IsPackOutUnsigned(flags)) {
-          // unsigned -> unsigned
-          assert_always();
-        } else {
-          // unsigned -> signed
-          assert_always();
-        }
-      } else {
-        if (IsPackOutUnsigned(flags)) {
-          // signed -> unsigned
-          assert_always();
-        } else {
-          // signed -> signed
-          e.vpshufb(i.dest, src, e.GetXmmConstPtr(XMMByteOrderMask));
-          e.vpunpckhbw(i.dest, i.dest, i.dest);
-          e.vpsraw(i.dest, 8);
-        }
-      }
-    } else {
-      // Unpack to HI.
-      if (IsPackInUnsigned(flags)) {
-        if (IsPackOutUnsigned(flags)) {
-          // unsigned -> unsigned
-          assert_always();
-        } else {
-          // unsigned -> signed
-          assert_always();
-        }
-      } else {
-        if (IsPackOutUnsigned(flags)) {
-          // signed -> unsigned
-          assert_always();
-        } else {
-          // signed -> signed
-          e.vpshufb(i.dest, src, e.GetXmmConstPtr(XMMByteOrderMask));
-          e.vpunpcklbw(i.dest, i.dest, i.dest);
-          e.vpsraw(i.dest, 8);
-        }
-      }
-    }
-  }
-  static void Emit16_IN_32(X64Emitter& e, const EmitArgType& i,
-                           uint32_t flags) {
-    assert_false(IsPackOutSaturate(flags));
-    Xmm src;
-    if (i.src1.is_constant) {
-      src = i.dest;
-      e.LoadConstantXmm(src, i.src1.constant());
-    } else {
-      src = i.src1;
-    }
-    if (IsPackToLo(flags)) {
-      // Unpack to LO.
-      if (IsPackInUnsigned(flags)) {
-        if (IsPackOutUnsigned(flags)) {
-          // unsigned -> unsigned
-          assert_always();
-        } else {
-          // unsigned -> signed
-          assert_always();
-        }
-      } else {
-        if (IsPackOutUnsigned(flags)) {
-          // signed -> unsigned
-          assert_always();
-        } else {
-          // signed -> signed
-          e.vpunpckhwd(i.dest, src, src);
-          e.vpsrad(i.dest, 16);
-        }
-      }
-    } else {
-      // Unpack to HI.
-      if (IsPackInUnsigned(flags)) {
-        if (IsPackOutUnsigned(flags)) {
-          // unsigned -> unsigned
-          assert_always();
-        } else {
-          // unsigned -> signed
-          assert_always();
-        }
-      } else {
-        if (IsPackOutUnsigned(flags)) {
-          // signed -> unsigned
-          assert_always();
-        } else {
-          // signed -> signed
-          e.vpunpcklwd(i.dest, src, src);
-          e.vpsrad(i.dest, 16);
-        }
-      }
-    }
-    e.vpshufd(i.dest, i.dest, 0xB1);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_UNPACK, UNPACK);
-
-// ============================================================================
-// OPCODE_ATOMIC_EXCHANGE
-// ============================================================================
-// Note that the address we use here is a real, host address!
-// This is weird, and should be fixed.
-template <typename SEQ, typename REG, typename ARGS>
-void EmitAtomicExchangeXX(X64Emitter& e, const ARGS& i) {
-  if (i.dest == i.src1) {
-    e.mov(e.rax, i.src1);
-    if (i.dest != i.src2) {
-      if (i.src2.is_constant) {
-        e.mov(i.dest, i.src2.constant());
-      } else {
-        e.mov(i.dest, i.src2);
-      }
-    }
-    e.lock();
-    e.xchg(e.dword[e.rax], i.dest);
-  } else {
-    if (i.dest != i.src2) {
-      if (i.src2.is_constant) {
-        e.mov(i.dest, i.src2.constant());
-      } else {
-        e.mov(i.dest, i.src2);
-      }
-    }
-    e.lock();
-    e.xchg(e.dword[i.src1.reg()], i.dest);
-  }
-}
-struct ATOMIC_EXCHANGE_I8
-    : Sequence<ATOMIC_EXCHANGE_I8,
-               I<OPCODE_ATOMIC_EXCHANGE, I8Op, I64Op, I8Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    EmitAtomicExchangeXX<ATOMIC_EXCHANGE_I8, Reg8>(e, i);
-  }
-};
-struct ATOMIC_EXCHANGE_I16
-    : Sequence<ATOMIC_EXCHANGE_I16,
-               I<OPCODE_ATOMIC_EXCHANGE, I16Op, I64Op, I16Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    EmitAtomicExchangeXX<ATOMIC_EXCHANGE_I16, Reg16>(e, i);
-  }
-};
-struct ATOMIC_EXCHANGE_I32
-    : Sequence<ATOMIC_EXCHANGE_I32,
-               I<OPCODE_ATOMIC_EXCHANGE, I32Op, I64Op, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    EmitAtomicExchangeXX<ATOMIC_EXCHANGE_I32, Reg32>(e, i);
-  }
-};
-struct ATOMIC_EXCHANGE_I64
-    : Sequence<ATOMIC_EXCHANGE_I64,
-               I<OPCODE_ATOMIC_EXCHANGE, I64Op, I64Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    EmitAtomicExchangeXX<ATOMIC_EXCHANGE_I64, Reg64>(e, i);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_ATOMIC_EXCHANGE, ATOMIC_EXCHANGE_I8,
-                     ATOMIC_EXCHANGE_I16, ATOMIC_EXCHANGE_I32,
-                     ATOMIC_EXCHANGE_I64);
-
-// ============================================================================
-// OPCODE_ATOMIC_COMPARE_EXCHANGE
-// ============================================================================
-struct ATOMIC_COMPARE_EXCHANGE_I32
-    : Sequence<ATOMIC_COMPARE_EXCHANGE_I32,
-               I<OPCODE_ATOMIC_COMPARE_EXCHANGE, I8Op, I64Op, I32Op, I32Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.mov(e.eax, i.src2);
-    e.mov(e.ecx, i.src1.reg().cvt32());
-    e.lock();
-    e.cmpxchg(e.dword[e.GetMembaseReg() + e.rcx], i.src3);
-    e.sete(i.dest);
-  }
-};
-struct ATOMIC_COMPARE_EXCHANGE_I64
-    : Sequence<ATOMIC_COMPARE_EXCHANGE_I64,
-               I<OPCODE_ATOMIC_COMPARE_EXCHANGE, I8Op, I64Op, I64Op, I64Op>> {
-  static void Emit(X64Emitter& e, const EmitArgType& i) {
-    e.mov(e.rax, i.src2);
-    e.mov(e.ecx, i.src1.reg().cvt32());
-    e.lock();
-    e.cmpxchg(e.qword[e.GetMembaseReg() + e.rcx], i.src3);
-    e.sete(i.dest);
-  }
-};
-EMITTER_OPCODE_TABLE(OPCODE_ATOMIC_COMPARE_EXCHANGE,
-                     ATOMIC_COMPARE_EXCHANGE_I32, ATOMIC_COMPARE_EXCHANGE_I64);
-
 // ============================================================================
 // OPCODE_SET_ROUNDING_MODE
 // ============================================================================
@@ -7785,128 +3057,15 @@ struct SET_ROUNDING_MODE_I32
 };
 EMITTER_OPCODE_TABLE(OPCODE_SET_ROUNDING_MODE, SET_ROUNDING_MODE_I32);
 
-void RegisterSequences() {
-  Register_OPCODE_COMMENT();
-  Register_OPCODE_NOP();
-  Register_OPCODE_SOURCE_OFFSET();
-  Register_OPCODE_DEBUG_BREAK();
-  Register_OPCODE_DEBUG_BREAK_TRUE();
-  Register_OPCODE_TRAP();
-  Register_OPCODE_TRAP_TRUE();
-  Register_OPCODE_CALL();
-  Register_OPCODE_CALL_TRUE();
-  Register_OPCODE_CALL_INDIRECT();
-  Register_OPCODE_CALL_INDIRECT_TRUE();
-  Register_OPCODE_CALL_EXTERN();
-  Register_OPCODE_RETURN();
-  Register_OPCODE_RETURN_TRUE();
-  Register_OPCODE_SET_RETURN_ADDRESS();
-  Register_OPCODE_BRANCH();
-  Register_OPCODE_BRANCH_TRUE();
-  Register_OPCODE_BRANCH_FALSE();
-  Register_OPCODE_ASSIGN();
-  Register_OPCODE_CAST();
-  Register_OPCODE_ZERO_EXTEND();
-  Register_OPCODE_SIGN_EXTEND();
-  Register_OPCODE_TRUNCATE();
-  Register_OPCODE_CONVERT();
-  Register_OPCODE_ROUND();
-  Register_OPCODE_VECTOR_CONVERT_I2F();
-  Register_OPCODE_VECTOR_CONVERT_F2I();
-  Register_OPCODE_LOAD_VECTOR_SHL();
-  Register_OPCODE_LOAD_VECTOR_SHR();
-  Register_OPCODE_LOAD_CLOCK();
-  Register_OPCODE_LOAD_LOCAL();
-  Register_OPCODE_STORE_LOCAL();
-  Register_OPCODE_LOAD_CONTEXT();
-  Register_OPCODE_STORE_CONTEXT();
-  Register_OPCODE_CONTEXT_BARRIER();
-  Register_OPCODE_LOAD_MMIO();
-  Register_OPCODE_STORE_MMIO();
-  Register_OPCODE_LOAD_OFFSET();
-  Register_OPCODE_STORE_OFFSET();
-  Register_OPCODE_LOAD();
-  Register_OPCODE_STORE();
-  Register_OPCODE_MEMSET();
-  Register_OPCODE_PREFETCH();
-  Register_OPCODE_MEMORY_BARRIER();
-  Register_OPCODE_MAX();
-  Register_OPCODE_VECTOR_MAX();
-  Register_OPCODE_MIN();
-  Register_OPCODE_VECTOR_MIN();
-  Register_OPCODE_SELECT();
-  Register_OPCODE_IS_TRUE();
-  Register_OPCODE_IS_FALSE();
-  Register_OPCODE_IS_NAN();
-  Register_OPCODE_COMPARE_EQ();
-  Register_OPCODE_COMPARE_NE();
-  Register_OPCODE_COMPARE_SLT();
-  Register_OPCODE_COMPARE_SLE();
-  Register_OPCODE_COMPARE_SGT();
-  Register_OPCODE_COMPARE_SGE();
-  Register_OPCODE_COMPARE_ULT();
-  Register_OPCODE_COMPARE_ULE();
-  Register_OPCODE_COMPARE_UGT();
-  Register_OPCODE_COMPARE_UGE();
-  Register_OPCODE_COMPARE_SLT_FLT();
-  Register_OPCODE_COMPARE_SLE_FLT();
-  Register_OPCODE_COMPARE_SGT_FLT();
-  Register_OPCODE_COMPARE_SGE_FLT();
-  Register_OPCODE_COMPARE_ULT_FLT();
-  Register_OPCODE_COMPARE_ULE_FLT();
-  Register_OPCODE_COMPARE_UGT_FLT();
-  Register_OPCODE_COMPARE_UGE_FLT();
-  Register_OPCODE_DID_SATURATE();
-  Register_OPCODE_VECTOR_COMPARE_EQ();
-  Register_OPCODE_VECTOR_COMPARE_SGT();
-  Register_OPCODE_VECTOR_COMPARE_SGE();
-  Register_OPCODE_VECTOR_COMPARE_UGT();
-  Register_OPCODE_VECTOR_COMPARE_UGE();
-  Register_OPCODE_ADD();
-  Register_OPCODE_ADD_CARRY();
-  Register_OPCODE_VECTOR_ADD();
-  Register_OPCODE_SUB();
-  Register_OPCODE_VECTOR_SUB();
-  Register_OPCODE_MUL();
-  Register_OPCODE_MUL_HI();
-  Register_OPCODE_DIV();
-  Register_OPCODE_MUL_ADD();
-  Register_OPCODE_MUL_SUB();
-  Register_OPCODE_NEG();
-  Register_OPCODE_ABS();
-  Register_OPCODE_SQRT();
-  Register_OPCODE_RSQRT();
-  Register_OPCODE_RECIP();
-  Register_OPCODE_POW2();
-  Register_OPCODE_LOG2();
-  Register_OPCODE_DOT_PRODUCT_3();
-  Register_OPCODE_DOT_PRODUCT_4();
-  Register_OPCODE_AND();
-  Register_OPCODE_OR();
-  Register_OPCODE_XOR();
-  Register_OPCODE_NOT();
-  Register_OPCODE_SHL();
-  Register_OPCODE_SHR();
-  Register_OPCODE_SHA();
-  Register_OPCODE_VECTOR_SHL();
-  Register_OPCODE_VECTOR_SHR();
-  Register_OPCODE_VECTOR_SHA();
-  Register_OPCODE_ROTATE_LEFT();
-  Register_OPCODE_VECTOR_ROTATE_LEFT();
-  Register_OPCODE_VECTOR_AVERAGE();
-  Register_OPCODE_BYTE_SWAP();
-  Register_OPCODE_CNTLZ();
-  Register_OPCODE_INSERT();
-  Register_OPCODE_EXTRACT();
-  Register_OPCODE_SPLAT();
-  Register_OPCODE_PERMUTE();
-  Register_OPCODE_SWIZZLE();
-  Register_OPCODE_PACK();
-  Register_OPCODE_UNPACK();
-  Register_OPCODE_ATOMIC_EXCHANGE();
-  Register_OPCODE_ATOMIC_COMPARE_EXCHANGE();
-  Register_OPCODE_SET_ROUNDING_MODE();
-}
+// Include anchors to other sequence sources so they get included in the build.
+extern volatile int anchor_control;
+static int anchor_control_dest = anchor_control;
+
+extern volatile int anchor_memory;
+static int anchor_memory_dest = anchor_memory;
+
+extern volatile int anchor_vector;
+static int anchor_vector_dest = anchor_vector;
 
 bool SelectSequence(X64Emitter* e, const Instr* i, const Instr** new_tail) {
   const InstrKey key(i);
diff --git a/src/xenia/cpu/backend/x64/x64_sequences.h b/src/xenia/cpu/backend/x64/x64_sequences.h
index a0103fca5..07b264ab2 100644
--- a/src/xenia/cpu/backend/x64/x64_sequences.h
+++ b/src/xenia/cpu/backend/x64/x64_sequences.h
@@ -12,6 +12,8 @@
 
 #include "xenia/cpu/hir/instr.h"
 
+#include <unordered_map>
+
 namespace xe {
 namespace cpu {
 namespace backend {
@@ -19,7 +21,25 @@ namespace x64 {
 
 class X64Emitter;
 
-void RegisterSequences();
+typedef bool (*SequenceSelectFn)(X64Emitter&, const hir::Instr*);
+extern std::unordered_map<uint32_t, SequenceSelectFn> sequence_table;
+
+template <typename T>
+bool Register() {
+  sequence_table.insert({T::head_key(), T::Select});
+  return true;
+}
+
+template <typename T, typename Tn, typename... Ts>
+static bool Register() {
+  bool b = true;
+  b = b && Register<T>();          // Call the above function
+  b = b && Register<Tn, Ts...>();  // Call ourself again (recursively)
+  return b;
+}
+#define EMITTER_OPCODE_TABLE(name, ...) \
+  const auto X64_INSTR_##name = Register<__VA_ARGS__>();
+
 bool SelectSequence(X64Emitter* e, const hir::Instr* i,
                     const hir::Instr** new_tail);
 
diff --git a/src/xenia/cpu/compiler/compiler_passes.h b/src/xenia/cpu/compiler/compiler_passes.h
index 6b81d1fb5..fc58ec710 100644
--- a/src/xenia/cpu/compiler/compiler_passes.h
+++ b/src/xenia/cpu/compiler/compiler_passes.h
@@ -10,6 +10,8 @@
 #ifndef XENIA_CPU_COMPILER_COMPILER_PASSES_H_
 #define XENIA_CPU_COMPILER_COMPILER_PASSES_H_
 
+#include "xenia/cpu/compiler/passes/conditional_group_pass.h"
+#include "xenia/cpu/compiler/passes/conditional_group_subpass.h"
 #include "xenia/cpu/compiler/passes/constant_propagation_pass.h"
 #include "xenia/cpu/compiler/passes/context_promotion_pass.h"
 #include "xenia/cpu/compiler/passes/control_flow_analysis_pass.h"
diff --git a/src/xenia/cpu/compiler/passes/conditional_group_pass.cc b/src/xenia/cpu/compiler/passes/conditional_group_pass.cc
new file mode 100644
index 000000000..ef84991e8
--- /dev/null
+++ b/src/xenia/cpu/compiler/passes/conditional_group_pass.cc
@@ -0,0 +1,85 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "xenia/cpu/compiler/passes/conditional_group_pass.h"
+
+#include <gflags/gflags.h>
+
+#include "xenia/base/profiling.h"
+#include "xenia/cpu/compiler/compiler.h"
+#include "xenia/cpu/ppc/ppc_context.h"
+#include "xenia/cpu/processor.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+// TODO(benvanik): remove when enums redefined.
+using namespace xe::cpu::hir;
+
+using xe::cpu::hir::Block;
+using xe::cpu::hir::HIRBuilder;
+using xe::cpu::hir::Instr;
+using xe::cpu::hir::Value;
+
+ConditionalGroupPass::ConditionalGroupPass() : CompilerPass() {}
+
+ConditionalGroupPass::~ConditionalGroupPass() {}
+
+bool ConditionalGroupPass::Initialize(Compiler* compiler) {
+  if (!CompilerPass::Initialize(compiler)) {
+    return false;
+  }
+
+  for (size_t i = 0; i < passes_.size(); ++i) {
+    auto& pass = passes_[i];
+    if (!pass->Initialize(compiler)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool ConditionalGroupPass::Run(HIRBuilder* builder) {
+  bool dirty;
+  int loops = 0;
+  do {
+    assert_true(loops < 20);  // arbitrary number
+    dirty = false;
+    for (size_t i = 0; i < passes_.size(); ++i) {
+      scratch_arena()->Reset();
+      auto& pass = passes_[i];
+      auto subpass = dynamic_cast<ConditionalGroupSubpass*>(pass.get());
+      if (!subpass) {
+        if (!pass->Run(builder)) {
+          return false;
+        }
+      } else {
+        bool result = false;
+        if (!subpass->Run(builder, result)) {
+          return false;
+        }
+        dirty |= result;
+      }
+    }
+    loops++;
+  } while (dirty);
+  return true;
+}
+
+void ConditionalGroupPass::AddPass(std::unique_ptr<CompilerPass> pass) {
+  passes_.push_back(std::move(pass));
+}
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
diff --git a/src/xenia/cpu/compiler/passes/conditional_group_pass.h b/src/xenia/cpu/compiler/passes/conditional_group_pass.h
new file mode 100644
index 000000000..7421fe1b5
--- /dev/null
+++ b/src/xenia/cpu/compiler/passes/conditional_group_pass.h
@@ -0,0 +1,45 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_CPU_COMPILER_PASSES_CONDITIONAL_GROUP_PASS_H_
+#define XENIA_CPU_COMPILER_PASSES_CONDITIONAL_GROUP_PASS_H_
+
+#include <cmath>
+#include <vector>
+
+#include "xenia/base/platform.h"
+#include "xenia/cpu/compiler/compiler_pass.h"
+#include "xenia/cpu/compiler/passes/conditional_group_subpass.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+class ConditionalGroupPass : public CompilerPass {
+ public:
+  ConditionalGroupPass();
+  virtual ~ConditionalGroupPass() override;
+
+  bool Initialize(Compiler* compiler) override;
+
+  bool Run(hir::HIRBuilder* builder) override;
+
+  void AddPass(std::unique_ptr<CompilerPass> pass);
+
+ private:
+  std::vector<std::unique_ptr<CompilerPass>> passes_;
+};
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_CPU_COMPILER_PASSES_CONDITIONAL_GROUP_PASS_H_
diff --git a/src/xenia/cpu/compiler/passes/conditional_group_subpass.cc b/src/xenia/cpu/compiler/passes/conditional_group_subpass.cc
new file mode 100644
index 000000000..39780e2f5
--- /dev/null
+++ b/src/xenia/cpu/compiler/passes/conditional_group_subpass.cc
@@ -0,0 +1,26 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "xenia/cpu/compiler/passes/conditional_group_subpass.h"
+
+#include "xenia/cpu/compiler/compiler.h"
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+namespace passes {
+
+ConditionalGroupSubpass::ConditionalGroupSubpass() : CompilerPass() {}
+
+ConditionalGroupSubpass::~ConditionalGroupSubpass() = default;
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
diff --git a/src/xenia/cpu/compiler/passes/conditional_group_subpass.h b/src/xenia/cpu/compiler/passes/conditional_group_subpass.h
new file mode 100644
index 000000000..f62c50ed3
--- /dev/null
+++ b/src/xenia/cpu/compiler/passes/conditional_group_subpass.h
@@ -0,0 +1,47 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_CPU_COMPILER_PASSES_CONDITIONAL_GROUP_SUBPASS_H_
+#define XENIA_CPU_COMPILER_PASSES_CONDITIONAL_GROUP_SUBPASS_H_
+
+#include "xenia/base/arena.h"
+#include "xenia/cpu/compiler/compiler_pass.h"
+#include "xenia/cpu/hir/hir_builder.h"
+
+namespace xe {
+namespace cpu {
+class Processor;
+}  // namespace cpu
+}  // namespace xe
+
+namespace xe {
+namespace cpu {
+namespace compiler {
+class Compiler;
+namespace passes {
+
+class ConditionalGroupSubpass : public CompilerPass {
+ public:
+  ConditionalGroupSubpass();
+  virtual ~ConditionalGroupSubpass();
+
+  bool Run(hir::HIRBuilder* builder) override {
+    bool dummy;
+    return Run(builder, dummy);
+  }
+
+  virtual bool Run(hir::HIRBuilder* builder, bool& result) = 0;
+};
+
+}  // namespace passes
+}  // namespace compiler
+}  // namespace cpu
+}  // namespace xe
+
+#endif  // XENIA_CPU_COMPILER_PASSES_CONDITIONAL_GROUP_SUBPASS_H_
diff --git a/src/xenia/cpu/compiler/passes/constant_propagation_pass.cc b/src/xenia/cpu/compiler/passes/constant_propagation_pass.cc
index 8c3e7f196..3a399cefd 100644
--- a/src/xenia/cpu/compiler/passes/constant_propagation_pass.cc
+++ b/src/xenia/cpu/compiler/passes/constant_propagation_pass.cc
@@ -31,11 +31,12 @@ using xe::cpu::hir::HIRBuilder;
 using xe::cpu::hir::TypeName;
 using xe::cpu::hir::Value;
 
-ConstantPropagationPass::ConstantPropagationPass() : CompilerPass() {}
+ConstantPropagationPass::ConstantPropagationPass()
+    : ConditionalGroupSubpass() {}
 
 ConstantPropagationPass::~ConstantPropagationPass() {}
 
-bool ConstantPropagationPass::Run(HIRBuilder* builder) {
+bool ConstantPropagationPass::Run(HIRBuilder* builder, bool& result) {
   // Once ContextPromotion has run there will likely be a whole slew of
   // constants that can be pushed through the function.
   // Example:
@@ -63,6 +64,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
   //   v1 = 19
   //   v2 = 0
 
+  result = false;
   auto block = builder->first_block();
   while (block) {
     auto i = block->instr_head;
@@ -76,6 +78,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             } else {
               i->Remove();
             }
+            result = true;
           }
           break;
 
@@ -86,6 +89,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             } else {
               i->Remove();
             }
+            result = true;
           }
           break;
 
@@ -98,6 +102,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             } else {
               i->Remove();
             }
+            result = true;
           }
           break;
         case OPCODE_CALL_INDIRECT:
@@ -109,6 +114,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             }
             i->Replace(&OPCODE_CALL_info, i->flags);
             i->src1.symbol = function;
+            result = true;
           }
           break;
         case OPCODE_CALL_INDIRECT_TRUE:
@@ -120,6 +126,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             } else {
               i->Remove();
             }
+            result = true;
           }
           break;
 
@@ -132,6 +139,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             } else {
               i->Remove();
             }
+            result = true;
           }
           break;
         case OPCODE_BRANCH_FALSE:
@@ -143,6 +151,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             } else {
               i->Remove();
             }
+            result = true;
           }
           break;
 
@@ -152,6 +161,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Cast(target_type);
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_CONVERT:
@@ -160,6 +170,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Convert(target_type, RoundMode(i->flags));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_ROUND:
@@ -167,6 +178,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Round(RoundMode(i->flags));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_ZERO_EXTEND:
@@ -175,6 +187,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->ZeroExtend(target_type);
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_SIGN_EXTEND:
@@ -183,6 +196,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->SignExtend(target_type);
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_TRUNCATE:
@@ -191,6 +205,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Truncate(target_type);
             i->Remove();
+            result = true;
           }
           break;
 
@@ -210,6 +225,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
               i->Replace(&OPCODE_LOAD_MMIO_info, 0);
               i->src1.offset = reinterpret_cast<uint64_t>(mmio_range);
               i->src2.offset = address;
+              result = true;
             } else {
               auto heap = memory->LookupHeap(address);
               uint32_t protect;
@@ -222,18 +238,22 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
                   case INT8_TYPE:
                     v->set_constant(xe::load<uint8_t>(host_addr));
                     i->Remove();
+                    result = true;
                     break;
                   case INT16_TYPE:
                     v->set_constant(xe::load<uint16_t>(host_addr));
                     i->Remove();
+                    result = true;
                     break;
                   case INT32_TYPE:
                     v->set_constant(xe::load<uint32_t>(host_addr));
                     i->Remove();
+                    result = true;
                     break;
                   case INT64_TYPE:
                     v->set_constant(xe::load<uint64_t>(host_addr));
                     i->Remove();
+                    result = true;
                     break;
                   case VEC128_TYPE:
                     vec128_t val;
@@ -241,6 +261,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
                     val.high = xe::load<uint64_t>(host_addr + 8);
                     v->set_constant(val);
                     i->Remove();
+                    result = true;
                     break;
                   default:
                     assert_unhandled_case(v->type);
@@ -270,6 +291,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
               i->src1.offset = reinterpret_cast<uint64_t>(mmio_range);
               i->src2.offset = address;
               i->set_src3(value);
+              result = true;
             }
           }
           break;
@@ -278,11 +300,15 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
           if (i->src1.value->IsConstant()) {
             if (i->src1.value->type != VEC128_TYPE) {
               if (i->src1.value->IsConstantTrue()) {
-                v->set_from(i->src2.value);
-                i->Remove();
+                auto src2 = i->src2.value;
+                i->Replace(&OPCODE_ASSIGN_info, 0);
+                i->set_src1(src2);
+                result = true;
               } else if (i->src1.value->IsConstantFalse()) {
-                v->set_from(i->src3.value);
-                i->Remove();
+                auto src3 = i->src3.value;
+                i->Replace(&OPCODE_ASSIGN_info, 0);
+                i->set_src1(src3);
+                result = true;
               } else if (i->src2.value->IsConstant() &&
                          i->src3.value->IsConstant()) {
                 // TODO: Select
@@ -303,6 +329,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
               v->set_constant(uint8_t(0));
             }
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_IS_FALSE:
@@ -313,6 +340,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
               v->set_constant(uint8_t(0));
             }
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_IS_NAN:
@@ -327,6 +355,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
               v->set_constant(uint8_t(0));
             }
             i->Remove();
+            result = true;
           }
           break;
 
@@ -336,6 +365,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             bool value = i->src1.value->IsConstantEQ(i->src2.value);
             i->dest->set_constant(uint8_t(value));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_COMPARE_NE:
@@ -343,6 +373,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             bool value = i->src1.value->IsConstantNE(i->src2.value);
             i->dest->set_constant(uint8_t(value));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_COMPARE_SLT:
@@ -350,6 +381,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             bool value = i->src1.value->IsConstantSLT(i->src2.value);
             i->dest->set_constant(uint8_t(value));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_COMPARE_SLE:
@@ -357,6 +389,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             bool value = i->src1.value->IsConstantSLE(i->src2.value);
             i->dest->set_constant(uint8_t(value));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_COMPARE_SGT:
@@ -364,6 +397,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             bool value = i->src1.value->IsConstantSGT(i->src2.value);
             i->dest->set_constant(uint8_t(value));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_COMPARE_SGE:
@@ -371,6 +405,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             bool value = i->src1.value->IsConstantSGE(i->src2.value);
             i->dest->set_constant(uint8_t(value));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_COMPARE_ULT:
@@ -378,6 +413,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             bool value = i->src1.value->IsConstantULT(i->src2.value);
             i->dest->set_constant(uint8_t(value));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_COMPARE_ULE:
@@ -385,6 +421,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             bool value = i->src1.value->IsConstantULE(i->src2.value);
             i->dest->set_constant(uint8_t(value));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_COMPARE_UGT:
@@ -392,6 +429,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             bool value = i->src1.value->IsConstantUGT(i->src2.value);
             i->dest->set_constant(uint8_t(value));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_COMPARE_UGE:
@@ -399,6 +437,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             bool value = i->src1.value->IsConstantUGE(i->src2.value);
             i->dest->set_constant(uint8_t(value));
             i->Remove();
+            result = true;
           }
           break;
 
@@ -411,6 +450,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Add(i->src2.value);
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_ADD_CARRY:
@@ -431,6 +471,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
                 i->set_src1(ca);
               }
             }
+            result = true;
           }
           break;
         case OPCODE_SUB:
@@ -438,6 +479,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Sub(i->src2.value);
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_MUL:
@@ -445,6 +487,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Mul(i->src2.value);
             i->Remove();
+            result = true;
           } else if (i->src1.value->IsConstant() ||
                      i->src2.value->IsConstant()) {
             // Reorder the sources to make things simpler.
@@ -458,12 +501,14 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             if (s2->type != VEC128_TYPE && s2->IsConstantOne()) {
               i->Replace(&OPCODE_ASSIGN_info, 0);
               i->set_src1(s1);
+              result = true;
             } else if (s2->type == VEC128_TYPE) {
               auto& c = s2->constant;
               if (c.v128.f32[0] == 1.f && c.v128.f32[1] == 1.f &&
                   c.v128.f32[2] == 1.f && c.v128.f32[3] == 1.f) {
                 i->Replace(&OPCODE_ASSIGN_info, 0);
                 i->set_src1(s1);
+                result = true;
               }
             }
           }
@@ -473,6 +518,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->MulHi(i->src2.value, (i->flags & ARITHMETIC_UNSIGNED) != 0);
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_DIV:
@@ -480,6 +526,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Div(i->src2.value, (i->flags & ARITHMETIC_UNSIGNED) != 0);
             i->Remove();
+            result = true;
           } else if (i->src2.value->IsConstant()) {
             // Division by one = no-op.
             Value* src1 = i->src1.value;
@@ -487,12 +534,14 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
                 i->src2.value->IsConstantOne()) {
               i->Replace(&OPCODE_ASSIGN_info, 0);
               i->set_src1(src1);
+              result = true;
             } else if (i->src2.value->type == VEC128_TYPE) {
               auto& c = i->src2.value->constant;
               if (c.v128.f32[0] == 1.f && c.v128.f32[1] == 1.f &&
                   c.v128.f32[2] == 1.f && c.v128.f32[3] == 1.f) {
                 i->Replace(&OPCODE_ASSIGN_info, 0);
                 i->set_src1(src1);
+                result = true;
               }
             }
           }
@@ -503,6 +552,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
               v->set_from(i->src1.value);
               Value::MulAdd(v, i->src1.value, i->src2.value, i->src3.value);
               i->Remove();
+              result = true;
             } else {
               // Multiply part is constant.
               Value* mul = builder->AllocValue();
@@ -513,6 +563,8 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
               i->Replace(&OPCODE_ADD_info, 0);
               i->set_src1(mul);
               i->set_src2(add);
+
+              result = true;
             }
           }
           break;
@@ -523,6 +575,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
               v->set_from(i->src1.value);
               Value::MulSub(v, i->src1.value, i->src2.value, i->src3.value);
               i->Remove();
+              result = true;
             } else {
               // Multiply part is constant.
               Value* mul = builder->AllocValue();
@@ -533,6 +586,8 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
               i->Replace(&OPCODE_SUB_info, 0);
               i->set_src1(mul);
               i->set_src2(add);
+
+              result = true;
             }
           }
           break;
@@ -541,6 +596,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Max(i->src2.value);
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_NEG:
@@ -548,6 +604,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Neg();
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_ABS:
@@ -555,6 +612,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Abs();
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_SQRT:
@@ -562,6 +620,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Sqrt();
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_RSQRT:
@@ -569,6 +628,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->RSqrt();
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_RECIP:
@@ -576,6 +636,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Recip();
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_AND:
@@ -583,6 +644,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->And(i->src2.value);
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_OR:
@@ -590,6 +652,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Or(i->src2.value);
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_XOR:
@@ -597,11 +660,13 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Xor(i->src2.value);
             i->Remove();
+            result = true;
           } else if (!i->src1.value->IsConstant() &&
                      !i->src2.value->IsConstant() &&
                      i->src1.value == i->src2.value) {
             v->set_zero(v->type);
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_NOT:
@@ -609,6 +674,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Not();
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_SHL:
@@ -616,6 +682,12 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Shl(i->src2.value);
             i->Remove();
+            result = true;
+          } else if (i->src2.value->IsConstantZero()) {
+            auto src1 = i->src1.value;
+            i->Replace(&OPCODE_ASSIGN_info, 0);
+            i->set_src1(src1);
+            result = true;
           }
           break;
         case OPCODE_SHR:
@@ -623,6 +695,12 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Shr(i->src2.value);
             i->Remove();
+            result = true;
+          } else if (i->src2.value->IsConstantZero()) {
+            auto src1 = i->src1.value;
+            i->Replace(&OPCODE_ASSIGN_info, 0);
+            i->set_src1(src1);
+            result = true;
           }
           break;
         case OPCODE_SHA:
@@ -630,6 +708,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->Sha(i->src2.value);
             i->Remove();
+            result = true;
           }
           break;
         // TODO(benvanik): ROTATE_LEFT
@@ -638,6 +717,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->ByteSwap();
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_CNTLZ:
@@ -645,6 +725,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_zero(v->type);
             v->CountLeadingZeros(i->src1.value);
             i->Remove();
+            result = true;
           }
           break;
         // TODO(benvanik): INSERT/EXTRACT
@@ -654,6 +735,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_zero(v->type);
             v->Extract(i->src1.value, i->src2.value);
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_SPLAT:
@@ -661,6 +743,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_zero(v->type);
             v->Splat(i->src1.value);
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_VECTOR_COMPARE_EQ:
@@ -668,6 +751,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->VectorCompareEQ(i->src2.value, hir::TypeName(i->flags));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_VECTOR_COMPARE_SGT:
@@ -675,6 +759,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->VectorCompareSGT(i->src2.value, hir::TypeName(i->flags));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_VECTOR_COMPARE_SGE:
@@ -682,6 +767,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->VectorCompareSGE(i->src2.value, hir::TypeName(i->flags));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_VECTOR_COMPARE_UGT:
@@ -689,6 +775,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->VectorCompareUGT(i->src2.value, hir::TypeName(i->flags));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_VECTOR_COMPARE_UGE:
@@ -696,6 +783,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->VectorCompareUGE(i->src2.value, hir::TypeName(i->flags));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_VECTOR_CONVERT_F2I:
@@ -704,6 +792,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->VectorConvertF2I(i->src1.value,
                                 !!(i->flags & ARITHMETIC_UNSIGNED));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_VECTOR_CONVERT_I2F:
@@ -712,6 +801,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->VectorConvertI2F(i->src1.value,
                                 !!(i->flags & ARITHMETIC_UNSIGNED));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_VECTOR_SHL:
@@ -719,6 +809,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->VectorShl(i->src2.value, hir::TypeName(i->flags));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_VECTOR_SHR:
@@ -726,6 +817,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->VectorShr(i->src2.value, hir::TypeName(i->flags));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_VECTOR_ROTATE_LEFT:
@@ -733,6 +825,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->VectorRol(i->src2.value, hir::TypeName(i->flags));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_VECTOR_ADD:
@@ -743,6 +836,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
                          !!(arith_flags & ARITHMETIC_UNSIGNED),
                          !!(arith_flags & ARITHMETIC_SATURATE));
             i->Remove();
+            result = true;
           }
           break;
         case OPCODE_VECTOR_SUB:
@@ -753,6 +847,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
                          !!(arith_flags & ARITHMETIC_UNSIGNED),
                          !!(arith_flags & ARITHMETIC_SATURATE));
             i->Remove();
+            result = true;
           }
           break;
 
@@ -761,6 +856,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->DotProduct3(i->src2.value);
             i->Remove();
+            result = true;
           }
           break;
 
@@ -769,6 +865,19 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder) {
             v->set_from(i->src1.value);
             v->DotProduct4(i->src2.value);
             i->Remove();
+            result = true;
+          }
+          break;
+
+        case OPCODE_VECTOR_AVERAGE:
+          if (i->src1.value->IsConstant() && i->src2.value->IsConstant()) {
+            v->set_from(i->src1.value);
+            uint32_t arith_flags = i->flags >> 8;
+            v->VectorAverage(i->src2.value, hir::TypeName(i->flags & 0xFF),
+                             !!(arith_flags & ARITHMETIC_UNSIGNED),
+                             !!(arith_flags & ARITHMETIC_SATURATE));
+            i->Remove();
+            result = true;
           }
           break;
 
diff --git a/src/xenia/cpu/compiler/passes/constant_propagation_pass.h b/src/xenia/cpu/compiler/passes/constant_propagation_pass.h
index 021bdc981..08bd25b4a 100644
--- a/src/xenia/cpu/compiler/passes/constant_propagation_pass.h
+++ b/src/xenia/cpu/compiler/passes/constant_propagation_pass.h
@@ -10,19 +10,19 @@
 #ifndef XENIA_CPU_COMPILER_PASSES_CONSTANT_PROPAGATION_PASS_H_
 #define XENIA_CPU_COMPILER_PASSES_CONSTANT_PROPAGATION_PASS_H_
 
-#include "xenia/cpu/compiler/compiler_pass.h"
+#include "xenia/cpu/compiler/passes/conditional_group_subpass.h"
 
 namespace xe {
 namespace cpu {
 namespace compiler {
 namespace passes {
 
-class ConstantPropagationPass : public CompilerPass {
+class ConstantPropagationPass : public ConditionalGroupSubpass {
  public:
   ConstantPropagationPass();
   ~ConstantPropagationPass() override;
 
-  bool Run(hir::HIRBuilder* builder) override;
+  bool Run(hir::HIRBuilder* builder, bool& result) override;
 
  private:
 };
diff --git a/src/xenia/cpu/compiler/passes/register_allocation_pass.cc b/src/xenia/cpu/compiler/passes/register_allocation_pass.cc
index c65cde487..1b1f4acd3 100644
--- a/src/xenia/cpu/compiler/passes/register_allocation_pass.cc
+++ b/src/xenia/cpu/compiler/passes/register_allocation_pass.cc
@@ -489,7 +489,7 @@ int CompareValueUse(const Value::Use* a, const Value::Use* b) {
 }  // namespace
 void RegisterAllocationPass::SortUsageList(Value* value) {
   // Modified in-place linked list sort from:
-  // http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.c
+  // https://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.c
   if (!value->use_head) {
     return;
   }
diff --git a/src/xenia/cpu/compiler/passes/simplification_pass.cc b/src/xenia/cpu/compiler/passes/simplification_pass.cc
index 3278ab7c6..3569887a4 100644
--- a/src/xenia/cpu/compiler/passes/simplification_pass.cc
+++ b/src/xenia/cpu/compiler/passes/simplification_pass.cc
@@ -23,17 +23,18 @@ using xe::cpu::hir::HIRBuilder;
 using xe::cpu::hir::Instr;
 using xe::cpu::hir::Value;
 
-SimplificationPass::SimplificationPass() : CompilerPass() {}
+SimplificationPass::SimplificationPass() : ConditionalGroupSubpass() {}
 
 SimplificationPass::~SimplificationPass() {}
 
-bool SimplificationPass::Run(HIRBuilder* builder) {
-  EliminateConversions(builder);
-  SimplifyAssignments(builder);
+bool SimplificationPass::Run(HIRBuilder* builder, bool& result) {
+  result = false;
+  result |= EliminateConversions(builder);
+  result |= SimplifyAssignments(builder);
   return true;
 }
 
-void SimplificationPass::EliminateConversions(HIRBuilder* builder) {
+bool SimplificationPass::EliminateConversions(HIRBuilder* builder) {
   // First, we check for truncates/extensions that can be skipped.
   // This generates some assignments which then the second step will clean up.
   // Both zero/sign extends can be skipped:
@@ -43,6 +44,7 @@ void SimplificationPass::EliminateConversions(HIRBuilder* builder) {
   //   v1.i64 = zero/sign_extend v0.i32 (may be dead code removed later)
   //   v2.i32 = v0.i32
 
+  bool result = false;
   auto block = builder->first_block();
   while (block) {
     auto i = block->instr_head;
@@ -51,20 +53,21 @@ void SimplificationPass::EliminateConversions(HIRBuilder* builder) {
       // back to definition).
       if (i->opcode == &OPCODE_TRUNCATE_info) {
         // Matches zero/sign_extend + truncate.
-        CheckTruncate(i);
+        result |= CheckTruncate(i);
       } else if (i->opcode == &OPCODE_BYTE_SWAP_info) {
         // Matches byte swap + byte swap.
         // This is pretty rare within the same basic block, but is in the
         // memcpy hot path and (probably) worth it. Maybe.
-        CheckByteSwap(i);
+        result |= CheckByteSwap(i);
       }
       i = i->next;
     }
     block = block->next;
   }
+  return result;
 }
 
-void SimplificationPass::CheckTruncate(Instr* i) {
+bool SimplificationPass::CheckTruncate(Instr* i) {
   // Walk backward up src's chain looking for an extend. We may have
   // assigns, so skip those.
   auto src = i->src1.value;
@@ -80,6 +83,7 @@ void SimplificationPass::CheckTruncate(Instr* i) {
         // Types match, use original by turning this into an assign.
         i->Replace(&OPCODE_ASSIGN_info, 0);
         i->set_src1(def->src1.value);
+        return true;
       }
     } else if (def->opcode == &OPCODE_ZERO_EXTEND_info) {
       // Value comes from a zero extend.
@@ -87,12 +91,14 @@ void SimplificationPass::CheckTruncate(Instr* i) {
         // Types match, use original by turning this into an assign.
         i->Replace(&OPCODE_ASSIGN_info, 0);
         i->set_src1(def->src1.value);
+        return true;
       }
     }
   }
+  return false;
 }
 
-void SimplificationPass::CheckByteSwap(Instr* i) {
+bool SimplificationPass::CheckByteSwap(Instr* i) {
   // Walk backward up src's chain looking for a byte swap. We may have
   // assigns, so skip those.
   auto src = i->src1.value;
@@ -107,11 +113,13 @@ void SimplificationPass::CheckByteSwap(Instr* i) {
       // Types match, use original by turning this into an assign.
       i->Replace(&OPCODE_ASSIGN_info, 0);
       i->set_src1(def->src1.value);
+      return true;
     }
   }
+  return false;
 }
 
-void SimplificationPass::SimplifyAssignments(HIRBuilder* builder) {
+bool SimplificationPass::SimplifyAssignments(HIRBuilder* builder) {
   // Run over the instructions and rename assigned variables:
   //   v1 = v0
   //   v2 = v1
@@ -129,27 +137,35 @@ void SimplificationPass::SimplifyAssignments(HIRBuilder* builder) {
   // of that instr. Because we may have chains, we do this recursively until
   // we find a non-assign def.
 
+  bool result = false;
   auto block = builder->first_block();
   while (block) {
     auto i = block->instr_head;
     while (i) {
       uint32_t signature = i->opcode->signature;
       if (GET_OPCODE_SIG_TYPE_SRC1(signature) == OPCODE_SIG_TYPE_V) {
-        i->set_src1(CheckValue(i->src1.value));
+        bool modified = false;
+        i->set_src1(CheckValue(i->src1.value, modified));
+        result |= modified;
       }
       if (GET_OPCODE_SIG_TYPE_SRC2(signature) == OPCODE_SIG_TYPE_V) {
-        i->set_src2(CheckValue(i->src2.value));
+        bool modified = false;
+        i->set_src2(CheckValue(i->src2.value, modified));
+        result |= modified;
       }
       if (GET_OPCODE_SIG_TYPE_SRC3(signature) == OPCODE_SIG_TYPE_V) {
-        i->set_src3(CheckValue(i->src3.value));
+        bool modified = false;
+        i->set_src3(CheckValue(i->src3.value, modified));
+        result |= modified;
       }
       i = i->next;
     }
     block = block->next;
   }
+  return result;
 }
 
-Value* SimplificationPass::CheckValue(Value* value) {
+Value* SimplificationPass::CheckValue(Value* value, bool& result) {
   auto def = value->def;
   if (def && def->opcode == &OPCODE_ASSIGN_info) {
     // Value comes from an assignment - recursively find if it comes from
@@ -162,8 +178,10 @@ Value* SimplificationPass::CheckValue(Value* value) {
       }
       replacement = def->src1.value;
     }
+    result = true;
     return replacement;
   }
+  result = false;
   return value;
 }
 
diff --git a/src/xenia/cpu/compiler/passes/simplification_pass.h b/src/xenia/cpu/compiler/passes/simplification_pass.h
index 70275f8b4..2ba6efad7 100644
--- a/src/xenia/cpu/compiler/passes/simplification_pass.h
+++ b/src/xenia/cpu/compiler/passes/simplification_pass.h
@@ -10,27 +10,27 @@
 #ifndef XENIA_CPU_COMPILER_PASSES_SIMPLIFICATION_PASS_H_
 #define XENIA_CPU_COMPILER_PASSES_SIMPLIFICATION_PASS_H_
 
-#include "xenia/cpu/compiler/compiler_pass.h"
+#include "xenia/cpu/compiler/passes/conditional_group_subpass.h"
 
 namespace xe {
 namespace cpu {
 namespace compiler {
 namespace passes {
 
-class SimplificationPass : public CompilerPass {
+class SimplificationPass : public ConditionalGroupSubpass {
  public:
   SimplificationPass();
   ~SimplificationPass() override;
 
-  bool Run(hir::HIRBuilder* builder) override;
+  bool Run(hir::HIRBuilder* builder, bool& result) override;
 
  private:
-  void EliminateConversions(hir::HIRBuilder* builder);
-  void CheckTruncate(hir::Instr* i);
-  void CheckByteSwap(hir::Instr* i);
+  bool EliminateConversions(hir::HIRBuilder* builder);
+  bool CheckTruncate(hir::Instr* i);
+  bool CheckByteSwap(hir::Instr* i);
 
-  void SimplifyAssignments(hir::HIRBuilder* builder);
-  hir::Value* CheckValue(hir::Value* value);
+  bool SimplifyAssignments(hir::HIRBuilder* builder);
+  hir::Value* CheckValue(hir::Value* value, bool& result);
 };
 
 }  // namespace passes
diff --git a/src/xenia/cpu/export_resolver.h b/src/xenia/cpu/export_resolver.h
index 8e08f2b2a..df92b2c0c 100644
--- a/src/xenia/cpu/export_resolver.h
+++ b/src/xenia/cpu/export_resolver.h
@@ -19,9 +19,32 @@
 namespace xe {
 namespace cpu {
 
+enum class ExportCategory : uint8_t {
+  kNone = 0,
+  kAudio,
+  kAvatars,
+  kContent,
+  kDebug,
+  kFileSystem,
+  kInput,
+  kMemory,
+  kMisc,
+  kModules,
+  kNetworking,
+  kThreading,
+  kUI,
+  kUserProfiles,
+  kVideo,
+};
+
 struct ExportTag {
   typedef uint32_t type;
 
+  // packed like so:
+  // ll...... cccccccc ........ ..bihssi
+
+  static const int CategoryShift = 16;
+
   // Export is implemented in some form and can be used.
   static const type kImplemented = 1u << 0;
   // Export is a stub and is probably bad.
@@ -35,17 +58,6 @@ struct ExportTag {
   // Export blocks the calling thread
   static const type kBlocking = 1u << 5;
 
-  static const type kThreading = 1u << 10;
-  static const type kInput = 1u << 11;
-  static const type kAudio = 1u << 12;
-  static const type kVideo = 1u << 13;
-  static const type kFileSystem = 1u << 14;
-  static const type kModules = 1u << 15;
-  static const type kUserProfiles = 1u << 16;
-  static const type kNetworking = 1u << 17;
-  static const type kMemory = 1u << 18;
-  static const type kDebug = 1u << 19;
-
   // Export will be logged on each call.
   static const type kLog = 1u << 30;
   // Export's result will be logged on each call.
diff --git a/src/xenia/cpu/hir/hir_builder.cc b/src/xenia/cpu/hir/hir_builder.cc
index af954ca6c..e461996b5 100644
--- a/src/xenia/cpu/hir/hir_builder.cc
+++ b/src/xenia/cpu/hir/hir_builder.cc
@@ -764,7 +764,7 @@ void HIRBuilder::CommentFormat(const char* format, ...) {
   va_start(args, format);
   size_t chars_written = vsnprintf(p, kMaxCommentSize - 1, format, args);
   va_end(args);
-  size_t rewind = kMaxCommentSize - chars_written;
+  size_t rewind = kMaxCommentSize - chars_written - 1;
   arena_->Rewind(rewind);
   Instr* i = AppendInstr(OPCODE_COMMENT_info, 0);
   i->src1.offset = (uint64_t)p;
diff --git a/src/xenia/cpu/hir/value.cc b/src/xenia/cpu/hir/value.cc
index 38cd29294..ed79d65a2 100644
--- a/src/xenia/cpu/hir/value.cc
+++ b/src/xenia/cpu/hir/value.cc
@@ -1376,6 +1376,27 @@ void Value::DotProduct4(Value* other) {
   }
 }
 
+void Value::VectorAverage(Value* other, TypeName type, bool is_unsigned,
+                          bool saturate) {
+  assert_true(this->type == VEC128_TYPE && other->type == VEC128_TYPE);
+  switch (type) {
+    case INT16_TYPE: {
+      // TODO(gibbed): is this correct?
+      alignas(16) int8_t result[16];
+      __m128i src1 =
+          _mm_load_si128(reinterpret_cast<const __m128i*>(constant.v128.i8));
+      __m128i src2 = _mm_load_si128(
+          reinterpret_cast<const __m128i*>(other->constant.v128.i8));
+      __m128i dest = _mm_avg_epu16(src1, src2);
+      _mm_store_si128(reinterpret_cast<__m128i*>(result), dest);
+      std::memcpy(constant.v128.i8, result, sizeof(result));
+    } break;
+    default:
+      assert_unhandled_case(type);
+      break;
+  }
+}
+
 void Value::ByteSwap() {
   switch (type) {
     case INT8_TYPE:
diff --git a/src/xenia/cpu/hir/value.h b/src/xenia/cpu/hir/value.h
index 44e4807c4..dcc95ca8c 100644
--- a/src/xenia/cpu/hir/value.h
+++ b/src/xenia/cpu/hir/value.h
@@ -170,6 +170,7 @@ class Value {
     constant.v128 = value;
   }
   void set_from(const Value* other) {
+    assert_true(other->IsConstant());
     type = other->type;
     flags = other->flags;
     constant.v128 = other->constant.v128;
@@ -535,6 +536,8 @@ class Value {
   void VectorSub(Value* other, TypeName type, bool is_unsigned, bool saturate);
   void DotProduct3(Value* other);
   void DotProduct4(Value* other);
+  void VectorAverage(Value* other, TypeName type, bool is_unsigned,
+                     bool saturate);
   void ByteSwap();
   void CountLeadingZeros(const Value* other);
   bool Compare(Opcode opcode, Value* other);
diff --git a/src/xenia/cpu/lzx.cc b/src/xenia/cpu/lzx.cc
new file mode 100644
index 000000000..f6fd77a9a
--- /dev/null
+++ b/src/xenia/cpu/lzx.cc
@@ -0,0 +1,183 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "xenia/cpu/lzx.h"
+
+#include <algorithm>
+#include <climits>
+
+#include "xenia/base/byte_order.h"
+#include "xenia/base/logging.h"
+#include "xenia/base/math.h"
+#include "xenia/base/memory.h"
+#include "xenia/kernel/util/xex2_info.h"
+
+#include "third_party/mspack/lzx.h"
+#include "third_party/mspack/mspack.h"
+
+typedef struct mspack_memory_file_t {
+  struct mspack_system sys;
+  void* buffer;
+  off_t buffer_size;
+  off_t offset;
+} mspack_memory_file;
+mspack_memory_file* mspack_memory_open(struct mspack_system* sys, void* buffer,
+                                       const size_t buffer_size) {
+  assert_true(buffer_size < INT_MAX);
+  if (buffer_size >= INT_MAX) {
+    return NULL;
+  }
+  mspack_memory_file* memfile =
+      (mspack_memory_file*)calloc(1, sizeof(mspack_memory_file));
+  if (!memfile) {
+    return NULL;
+  }
+  memfile->buffer = buffer;
+  memfile->buffer_size = (off_t)buffer_size;
+  memfile->offset = 0;
+  return memfile;
+}
+void mspack_memory_close(mspack_memory_file* file) {
+  mspack_memory_file* memfile = (mspack_memory_file*)file;
+  free(memfile);
+}
+int mspack_memory_read(struct mspack_file* file, void* buffer, int chars) {
+  mspack_memory_file* memfile = (mspack_memory_file*)file;
+  const off_t remaining = memfile->buffer_size - memfile->offset;
+  const off_t total = std::min(static_cast<off_t>(chars), remaining);
+  std::memcpy(buffer, (uint8_t*)memfile->buffer + memfile->offset, total);
+  memfile->offset += total;
+  return (int)total;
+}
+int mspack_memory_write(struct mspack_file* file, void* buffer, int chars) {
+  mspack_memory_file* memfile = (mspack_memory_file*)file;
+  const off_t remaining = memfile->buffer_size - memfile->offset;
+  const off_t total = std::min(static_cast<off_t>(chars), remaining);
+  std::memcpy((uint8_t*)memfile->buffer + memfile->offset, buffer, total);
+  memfile->offset += total;
+  return (int)total;
+}
+void* mspack_memory_alloc(struct mspack_system* sys, size_t chars) {
+  return std::calloc(chars, 1);
+}
+void mspack_memory_free(void* ptr) { free(ptr); }
+void mspack_memory_copy(void* src, void* dest, size_t chars) {
+  std::memcpy(dest, src, chars);
+}
+struct mspack_system* mspack_memory_sys_create() {
+  struct mspack_system* sys =
+      (struct mspack_system*)std::calloc(1, sizeof(struct mspack_system));
+  if (!sys) {
+    return NULL;
+  }
+  sys->read = mspack_memory_read;
+  sys->write = mspack_memory_write;
+  sys->alloc = mspack_memory_alloc;
+  sys->free = mspack_memory_free;
+  sys->copy = mspack_memory_copy;
+  return sys;
+}
+void mspack_memory_sys_destroy(struct mspack_system* sys) { free(sys); }
+
+int lzx_decompress(const void* lzx_data, size_t lzx_len, void* dest,
+                   size_t dest_len, uint32_t window_size, void* window_data,
+                   size_t window_data_len) {
+  uint32_t window_bits = 0;
+  uint32_t temp_sz = window_size;
+  for (size_t m = 0; m < 32; m++, window_bits++) {
+    temp_sz >>= 1;
+    if (temp_sz == 0x00000000) {
+      break;
+    }
+  }
+
+  int result_code = 1;
+
+  mspack_system* sys = mspack_memory_sys_create();
+  mspack_memory_file* lzxsrc =
+      mspack_memory_open(sys, (void*)lzx_data, lzx_len);
+  mspack_memory_file* lzxdst = mspack_memory_open(sys, dest, dest_len);
+  lzxd_stream* lzxd =
+      lzxd_init(sys, (struct mspack_file*)lzxsrc, (struct mspack_file*)lzxdst,
+                window_bits, 0, 0x8000, (off_t)dest_len, 0);
+
+  if (lzxd) {
+    if (window_data) {
+      // zero the window and then copy window_data to the end of it
+      std::memset(lzxd->window, 0, window_data_len);
+      std::memcpy(lzxd->window + (window_size - window_data_len), window_data,
+                  window_data_len);
+      lzxd->ref_data_size = (uint32_t)window_data_len;
+    }
+
+    result_code = lzxd_decompress(lzxd, (off_t)dest_len);
+
+    lzxd_free(lzxd);
+    lzxd = NULL;
+  }
+  if (lzxsrc) {
+    mspack_memory_close(lzxsrc);
+    lzxsrc = NULL;
+  }
+  if (lzxdst) {
+    mspack_memory_close(lzxdst);
+    lzxdst = NULL;
+  }
+  if (sys) {
+    mspack_memory_sys_destroy(sys);
+    sys = NULL;
+  }
+
+  return result_code;
+}
+
+int lzxdelta_apply_patch(xe::xex2_delta_patch* patch, size_t patch_len,
+                         uint32_t window_size, void* dest) {
+  void* patch_end = (char*)patch + patch_len;
+  auto* cur_patch = patch;
+
+  while (patch_end > cur_patch) {
+    int patch_sz = -4;  // 0 byte patches need us to remove 4 byte from next
+                        // patch addr because of patch_data field
+    if (cur_patch->compressed_len == 0 && cur_patch->uncompressed_len == 0 &&
+        cur_patch->new_addr == 0 && cur_patch->old_addr == 0)
+      break;
+    switch (cur_patch->compressed_len) {
+      case 0:  // fill with 0
+        std::memset((char*)dest + cur_patch->new_addr, 0,
+                    cur_patch->uncompressed_len);
+        break;
+      case 1:  // copy from old -> new
+        std::memcpy((char*)dest + cur_patch->new_addr,
+                    (char*)dest + cur_patch->old_addr,
+                    cur_patch->uncompressed_len);
+        break;
+      default:  // delta patch
+        patch_sz =
+            cur_patch->compressed_len - 4;  // -4 because of patch_data field
+
+        int result = lzx_decompress(
+            cur_patch->patch_data, cur_patch->compressed_len,
+            (char*)dest + cur_patch->new_addr, cur_patch->uncompressed_len,
+            window_size, (char*)dest + cur_patch->old_addr,
+            cur_patch->uncompressed_len);
+
+        if (result) {
+          return result;
+        }
+        break;
+    }
+
+    cur_patch++;
+    cur_patch = (xe::xex2_delta_patch*)((char*)cur_patch +
+                                        patch_sz);  // TODO: make this less ugly
+  }
+
+  return 0;
+}
diff --git a/src/xenia/cpu/lzx.h b/src/xenia/cpu/lzx.h
new file mode 100644
index 000000000..72515f944
--- /dev/null
+++ b/src/xenia/cpu/lzx.h
@@ -0,0 +1,29 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_CPU_LZX_H_
+#define XENIA_CPU_LZX_H_
+
+#include <string>
+#include <vector>
+
+#include "xenia/cpu/module.h"
+
+namespace xe {
+struct xex2_delta_patch;
+}  // namespace xe
+
+int lzx_decompress(const void* lzx_data, size_t lzx_len, void* dest,
+                   size_t dest_len, uint32_t window_size, void* window_data,
+                   size_t window_data_len);
+
+int lzxdelta_apply_patch(xe::xex2_delta_patch* patch, size_t patch_len,
+                         uint32_t window_size, void* dest);
+
+#endif  // XENIA_CPU_LZX_H_
diff --git a/src/xenia/cpu/mmio_handler.cc b/src/xenia/cpu/mmio_handler.cc
index 33bdaf889..463ed2c43 100644
--- a/src/xenia/cpu/mmio_handler.cc
+++ b/src/xenia/cpu/mmio_handler.cc
@@ -316,7 +316,7 @@ bool TryDecodeMov(const uint8_t* p, DecodedMov* mov) {
   }
   if (p[i] == 0x0F && p[i + 1] == 0x38 && p[i + 2] == 0xF1) {
     // MOVBE m32, r32 (store)
-    // http://www.tptp.cc/mirrors/siyobik.info/instruction/MOVBE.html
+    // https://web.archive.org/web/20170629091435/https://www.tptp.cc/mirrors/siyobik.info/instruction/MOVBE.html
     // 44 0f 38 f1 a4 02 00     movbe  DWORD PTR [rdx+rax*1+0x0],r12d
     // 42 0f 38 f1 8c 22 00     movbe  DWORD PTR [rdx+r12*1+0x0],ecx
     // 0f 38 f1 8c 02 00 00     movbe  DWORD PTR [rdx + rax * 1 + 0x0], ecx
@@ -325,7 +325,7 @@ bool TryDecodeMov(const uint8_t* p, DecodedMov* mov) {
     i += 3;
   } else if (p[i] == 0x0F && p[i + 1] == 0x38 && p[i + 2] == 0xF0) {
     // MOVBE r32, m32 (load)
-    // http://www.tptp.cc/mirrors/siyobik.info/instruction/MOVBE.html
+    // https://web.archive.org/web/20170629091435/https://www.tptp.cc/mirrors/siyobik.info/instruction/MOVBE.html
     // 44 0f 38 f0 a4 02 00     movbe  r12d,DWORD PTR [rdx+rax*1+0x0]
     // 42 0f 38 f0 8c 22 00     movbe  ecx,DWORD PTR [rdx+r12*1+0x0]
     // 46 0f 38 f0 a4 22 00     movbe  r12d,DWORD PTR [rdx+r12*1+0x0]
@@ -336,7 +336,7 @@ bool TryDecodeMov(const uint8_t* p, DecodedMov* mov) {
     i += 3;
   } else if (p[i] == 0x89) {
     // MOV m32, r32 (store)
-    // http://www.tptp.cc/mirrors/siyobik.info/instruction/MOV.html
+    // https://web.archive.org/web/20170629072136/https://www.tptp.cc/mirrors/siyobik.info/instruction/MOV.html
     // 44 89 24 02              mov  DWORD PTR[rdx + rax * 1], r12d
     // 42 89 0c 22              mov  DWORD PTR[rdx + r12 * 1], ecx
     // 89 0c 02                 mov  DWORD PTR[rdx + rax * 1], ecx
@@ -345,7 +345,7 @@ bool TryDecodeMov(const uint8_t* p, DecodedMov* mov) {
     ++i;
   } else if (p[i] == 0x8B) {
     // MOV r32, m32 (load)
-    // http://www.tptp.cc/mirrors/siyobik.info/instruction/MOV.html
+    // https://web.archive.org/web/20170629072136/https://www.tptp.cc/mirrors/siyobik.info/instruction/MOV.html
     // 44 8b 24 02              mov  r12d, DWORD PTR[rdx + rax * 1]
     // 42 8b 0c 22              mov  ecx, DWORD PTR[rdx + r12 * 1]
     // 46 8b 24 22              mov  r12d, DWORD PTR[rdx + r12 * 1]
@@ -355,7 +355,7 @@ bool TryDecodeMov(const uint8_t* p, DecodedMov* mov) {
     ++i;
   } else if (p[i] == 0xC7) {
     // MOV m32, simm32
-    // http://www.asmpedia.org/index.php?title=MOV
+    // https://web.archive.org/web/20161017042413/https://www.asmpedia.org/index.php?title=MOV
     // C7 04 02 02 00 00 00     mov  dword ptr [rdx+rax],2
     mov->is_load = false;
     mov->byte_swap = false;
diff --git a/src/xenia/cpu/ppc/ppc_emit_altivec.cc b/src/xenia/cpu/ppc/ppc_emit_altivec.cc
index 577d04e62..b5b60af6d 100644
--- a/src/xenia/cpu/ppc/ppc_emit_altivec.cc
+++ b/src/xenia/cpu/ppc/ppc_emit_altivec.cc
@@ -31,7 +31,7 @@ Value* CalculateEA_0(PPCHIRBuilder& f, uint32_t ra, uint32_t rb);
 // Most of this file comes from:
 // http://biallas.net/doc/vmx128/vmx128.txt
 // https://github.com/kakaroto/ps3ida/blob/master/plugins/PPCAltivec/src/main.cpp
-// http://sannybuilder.com/forums/viewtopic.php?id=190
+// https://sannybuilder.com/forums/viewtopic.php?id=190
 
 #define OP(x) ((((uint32_t)(x)) & 0x3f) << 26)
 #define VX128(op, xop) (OP(op) | (((uint32_t)(xop)) & 0x3d0))
@@ -2068,7 +2068,7 @@ int InstrEmit_vpkd3d128(PPCHIRBuilder& f, const InstrData& i) {
       assert_unhandled_case(type);
       return 1;
   }
-  // http://hlssmod.net/he_code/public/pixelwriter.h
+  // https://hlssmod.net/he_code/public/pixelwriter.h
   // control = prev:0123 | new:4567
   uint32_t control = kIdentityPermuteMask;  // original
   switch (pack) {
@@ -2141,7 +2141,8 @@ int InstrEmit_vpkd3d128(PPCHIRBuilder& f, const InstrData& i) {
 
 int InstrEmit_vupkd3d128(PPCHIRBuilder& f, const InstrData& i) {
   // Can't find many docs on this. Best reference is
-  // http://worldcraft.googlecode.com/svn/trunk/src/qylib/math/xmmatrix.inl,
+  // https://code.google.com/archive/p/worldcraft/source/default/source?page=4
+  // (qylib/math/xmmatrix.inl)
   // which shows how it's used in some cases. Since it's all intrinsics,
   // finding it in code is pretty easy.
   const uint32_t vd = i.VX128_3.VD128l | (i.VX128_3.VD128h << 5);
diff --git a/src/xenia/cpu/ppc/ppc_emit_alu.cc b/src/xenia/cpu/ppc/ppc_emit_alu.cc
index 72780974f..1b0ed6327 100644
--- a/src/xenia/cpu/ppc/ppc_emit_alu.cc
+++ b/src/xenia/cpu/ppc/ppc_emit_alu.cc
@@ -1077,8 +1077,8 @@ int InstrEmit_srdx(PPCHIRBuilder& f, const InstrData& i) {
   // else
   //   m <- i64.0
   // RA <- r & m
-  // TODO(benvanik): if >3F, zero out the result.
-  Value* sh = f.Truncate(f.LoadGPR(i.X.RB), INT8_TYPE);
+  Value* sh =
+      f.And(f.Truncate(f.LoadGPR(i.X.RB), INT8_TYPE), f.LoadConstantInt8(0x7F));
   Value* v = f.Select(f.IsTrue(f.And(sh, f.LoadConstantInt8(0x40))),
                       f.LoadZeroInt64(), f.Shr(f.LoadGPR(i.X.RT), sh));
   f.StoreGPR(i.X.RA, v);
@@ -1096,8 +1096,8 @@ int InstrEmit_srwx(PPCHIRBuilder& f, const InstrData& i) {
   // else
   //   m <- i64.0
   // RA <- r & m
-  // TODO(benvanik): if >1F, zero out the result.
-  Value* sh = f.Truncate(f.LoadGPR(i.X.RB), INT8_TYPE);
+  Value* sh =
+      f.And(f.Truncate(f.LoadGPR(i.X.RB), INT8_TYPE), f.LoadConstantInt8(0x3F));
   Value* v =
       f.Select(f.IsTrue(f.And(sh, f.LoadConstantInt8(0x20))), f.LoadZeroInt32(),
                f.Shr(f.Truncate(f.LoadGPR(i.X.RT), INT32_TYPE), sh));
diff --git a/src/xenia/cpu/ppc/ppc_emit_fpu.cc b/src/xenia/cpu/ppc/ppc_emit_fpu.cc
index 24f2cd732..979ca3aa9 100644
--- a/src/xenia/cpu/ppc/ppc_emit_fpu.cc
+++ b/src/xenia/cpu/ppc/ppc_emit_fpu.cc
@@ -26,7 +26,7 @@ using xe::cpu::hir::RoundMode;
 using xe::cpu::hir::Value;
 
 // Good source of information:
-// http://mamedev.org/source/src/emu/cpu/powerpc/ppc_ops.c
+// https://github.com/mamedev/historic-mame/blob/master/src/emu/cpu/powerpc/ppc_ops.c
 // The correctness of that code is not reflected here yet -_-
 
 // Enable rounding numbers to single precision as required.
@@ -242,10 +242,20 @@ int InstrEmit_fcfidx(PPCHIRBuilder& f, const InstrData& i) {
 
 int InstrEmit_fctidxx_(PPCHIRBuilder& f, const InstrData& i,
                        RoundMode round_mode) {
-  Value* v = f.Convert(f.LoadFPR(i.X.RB), INT64_TYPE, round_mode);
+  auto end = f.NewLabel();
+  auto isnan = f.NewLabel();
+  Value* v;
+  f.BranchTrue(f.IsNan(f.LoadFPR(i.X.RB)), isnan);
+  v = f.Convert(f.LoadFPR(i.X.RB), INT64_TYPE, round_mode);
   v = f.Cast(v, FLOAT64_TYPE);
   f.StoreFPR(i.X.RT, v);
   f.UpdateFPSCR(v, i.X.Rc);
+  f.Branch(end);
+  f.MarkLabel(isnan);
+  v = f.Cast(f.LoadConstantUint64(0x8000000000000000u), FLOAT64_TYPE);
+  f.StoreFPR(i.X.RT, v);
+  f.UpdateFPSCR(v, i.X.Rc);
+  f.MarkLabel(end);
   return 0;
 }
 
@@ -260,10 +270,20 @@ int InstrEmit_fctidzx(PPCHIRBuilder& f, const InstrData& i) {
 
 int InstrEmit_fctiwxx_(PPCHIRBuilder& f, const InstrData& i,
                        RoundMode round_mode) {
-  Value* v = f.Convert(f.LoadFPR(i.X.RB), INT32_TYPE, round_mode);
+  auto end = f.NewLabel();
+  auto isnan = f.NewLabel();
+  Value* v;
+  f.BranchTrue(f.IsNan(f.LoadFPR(i.X.RB)), isnan);
+  v = f.Convert(f.LoadFPR(i.X.RB), INT32_TYPE, round_mode);
   v = f.Cast(f.SignExtend(v, INT64_TYPE), FLOAT64_TYPE);
   f.StoreFPR(i.X.RT, v);
   f.UpdateFPSCR(v, i.X.Rc);
+  f.Branch(end);
+  f.MarkLabel(isnan);
+  v = f.Cast(f.LoadConstantUint32(0x80000000u), FLOAT64_TYPE);
+  f.StoreFPR(i.X.RT, v);
+  f.UpdateFPSCR(v, i.X.Rc);
+  f.MarkLabel(end);
   return 0;
 }
 
diff --git a/src/xenia/cpu/ppc/ppc_emit_memory.cc b/src/xenia/cpu/ppc/ppc_emit_memory.cc
index 7cd4f19c1..79c951bcf 100644
--- a/src/xenia/cpu/ppc/ppc_emit_memory.cc
+++ b/src/xenia/cpu/ppc/ppc_emit_memory.cc
@@ -9,12 +9,11 @@
 
 #include "xenia/cpu/ppc/ppc_emit-private.h"
 
+#include <stddef.h>
 #include "xenia/base/assert.h"
 #include "xenia/cpu/ppc/ppc_context.h"
 #include "xenia/cpu/ppc/ppc_hir_builder.h"
 
-#include <stddef.h>
-
 namespace xe {
 namespace cpu {
 namespace ppc {
@@ -504,10 +503,26 @@ int InstrEmit_stw(PPCHIRBuilder& f, const InstrData& i) {
   } else {
     b = f.LoadGPR(i.D.RA);
   }
-
   Value* offset = f.LoadConstantInt64(XEEXTS16(i.D.DS));
   f.StoreOffset(b, offset,
                 f.ByteSwap(f.Truncate(f.LoadGPR(i.D.RT), INT32_TYPE)));
+
+  return 0;
+}
+
+int InstrEmit_stmw(PPCHIRBuilder& f, const InstrData& i) {
+  Value* b;
+  if (i.D.RA == 0) {
+    b = f.LoadZeroInt64();
+  } else {
+    b = f.LoadGPR(i.D.RA);
+  }
+
+  for (uint32_t j = 0; j < 32 - i.D.RT; ++j) {
+    Value* offset = f.LoadConstantInt64(XEEXTS16(i.D.DS) + j * 4);
+    f.StoreOffset(b, offset,
+                  f.ByteSwap(f.Truncate(f.LoadGPR(i.D.RT + j), INT32_TYPE)));
+  }
   return 0;
 }
 
@@ -674,13 +689,23 @@ int InstrEmit_stdbrx(PPCHIRBuilder& f, const InstrData& i) {
 // Integer load and store multiple (A-16)
 
 int InstrEmit_lmw(PPCHIRBuilder& f, const InstrData& i) {
-  XEINSTRNOTIMPLEMENTED();
-  return 1;
-}
+  Value* b;
+  if (i.D.RA == 0) {
+    b = f.LoadZeroInt64();
+  } else {
+    b = f.LoadGPR(i.D.RA);
+  }
 
-int InstrEmit_stmw(PPCHIRBuilder& f, const InstrData& i) {
-  XEINSTRNOTIMPLEMENTED();
-  return 1;
+  for (uint32_t j = 0; j < 32 - i.D.RT; ++j) {
+    if (i.D.RT + j == i.D.RA) {
+      continue;
+    }
+    Value* offset = f.LoadConstantInt64(XEEXTS16(i.D.DS) + j * 4);
+    Value* rt = f.ZeroExtend(f.ByteSwap(f.LoadOffset(b, offset, INT32_TYPE)),
+                             INT64_TYPE);
+    f.StoreGPR(i.D.RT + j, rt);
+  }
+  return 0;
 }
 
 // Integer load and store string (A-17)
diff --git a/src/xenia/cpu/ppc/ppc_translator.cc b/src/xenia/cpu/ppc/ppc_translator.cc
index 84aa47f99..d408f75b1 100644
--- a/src/xenia/cpu/ppc/ppc_translator.cc
+++ b/src/xenia/cpu/ppc/ppc_translator.cc
@@ -53,10 +53,16 @@ PPCTranslator::PPCTranslator(PPCFrontend* frontend) : frontend_(frontend) {
   if (validate) compiler_->AddPass(std::make_unique<passes::ValidationPass>());
   compiler_->AddPass(std::make_unique<passes::ContextPromotionPass>());
   if (validate) compiler_->AddPass(std::make_unique<passes::ValidationPass>());
-  compiler_->AddPass(std::make_unique<passes::SimplificationPass>());
-  if (validate) compiler_->AddPass(std::make_unique<passes::ValidationPass>());
-  compiler_->AddPass(std::make_unique<passes::ConstantPropagationPass>());
-  if (validate) compiler_->AddPass(std::make_unique<passes::ValidationPass>());
+
+  // Grouped simplification + constant propagation.
+  // Loops until no changes are made.
+  auto sap = std::make_unique<passes::ConditionalGroupPass>();
+  sap->AddPass(std::make_unique<passes::SimplificationPass>());
+  if (validate) sap->AddPass(std::make_unique<passes::ValidationPass>());
+  sap->AddPass(std::make_unique<passes::ConstantPropagationPass>());
+  if (validate) sap->AddPass(std::make_unique<passes::ValidationPass>());
+  compiler_->AddPass(std::move(sap));
+
   if (backend->machine_info()->supports_extended_load_store) {
     // Backend supports the advanced LOAD/STORE instructions.
     // These will save us a lot of HIR opcodes.
diff --git a/src/xenia/cpu/ppc/testing/instr_slw.s b/src/xenia/cpu/ppc/testing/instr_slw.s
index b1f4af3d1..e6548766a 100644
--- a/src/xenia/cpu/ppc/testing/instr_slw.s
+++ b/src/xenia/cpu/ppc/testing/instr_slw.s
@@ -159,3 +159,44 @@ test_slw_9_constant:
   #_ REGISTER_OUT r3 0
   #_ REGISTER_OUT r4 0xFFFFFFFFFFFFFFFF
   #_ REGISTER_OUT r5 32
+
+test_slw_10:
+  #_ REGISTER_IN r4 99
+  #_ REGISTER_IN r5 1
+  cntlzw r5, r5
+  subi r5, r5, 28
+  slw r3, r4, r5
+  blr
+  #_ REGISTER_OUT r3 792
+  #_ REGISTER_OUT r4 99
+  #_ REGISTER_OUT r5 3
+
+test_slw_10_constant:
+  #_ REGISTER_IN r4 99
+  li r5, 1
+  cntlzw r5, r5
+  subi r5, r5, 28
+  slw r3, r4, r5
+  blr
+  #_ REGISTER_OUT r3 792
+  #_ REGISTER_OUT r4 99
+  #_ REGISTER_OUT r5 3
+
+test_slw_11:
+  #_ REGISTER_IN r4 99
+  #_ REGISTER_IN r5 3
+  li r5, 3
+  slw r3, r4, r5
+  blr
+  #_ REGISTER_OUT r3 792
+  #_ REGISTER_OUT r4 99
+  #_ REGISTER_OUT r5 3
+
+test_slw_11_constant:
+  #_ REGISTER_IN r4 99
+  li r5, 3
+  slw r3, r4, r5
+  blr
+  #_ REGISTER_OUT r3 792
+  #_ REGISTER_OUT r4 99
+  #_ REGISTER_OUT r5 3
diff --git a/src/xenia/cpu/ppc/testing/instr_vpkd3d128.s b/src/xenia/cpu/ppc/testing/instr_vpkd3d128.s
index 7156dc4a7..e4acd59f2 100644
--- a/src/xenia/cpu/ppc/testing/instr_vpkd3d128.s
+++ b/src/xenia/cpu/ppc/testing/instr_vpkd3d128.s
@@ -36,6 +36,14 @@ test_vpkd3d128_d3dcolor_invalid_1:
   blr
   #_ REGISTER_OUT v3 [40800000, 40000000, C2F60000, 4B3BDF83]
   #_ REGISTER_OUT v4 [CDCDCDCD, CDCDCDCD, CDCDCDCD, FFFF0000]
+test_vpkd3d128_d3dcolor_invalid_2:
+  #_ REGISTER_IN v3 [40800000, 40000000, C2F60000, FFFFFFFF]
+  #_ REGISTER_IN v4 [CDCDCDCD, CDCDCDCD, CDCDCDCD, CDCDCDCD]
+  # vpkd3d128 v4, v3, 0, 1, 0
+  .long 0x18811E10
+  blr
+  #_ REGISTER_OUT v3 [40800000, 40000000, C2F60000, FFFFFFFF]
+  #_ REGISTER_OUT v4 [CDCDCDCD, CDCDCDCD, CDCDCDCD, 00FF0000]
 
 test_vpkd3d128_d3dcolor_1_0:
   #_ REGISTER_IN v3 [40400001, 40400002, 40400003, 40400004]
@@ -241,10 +249,10 @@ test_vpkd3d128_float16_4_invalid_0:
   #_ REGISTER_OUT v3 [3FC00000, BFC00000, 3FC00000, BFC00000]
   #_ REGISTER_OUT v4 [CDCDCDCD, CDCDCDCD, 3E00BE00, 3E00BE00]
 test_vpkd3d128_float16_4_0:
-  #_ REGISTER_IN v3 [3F000000, BF000000, 3F000000, BF000000]
+  #_ REGISTER_IN v3 [3F000000, BF000000, 3F800000, BF800000]
   #_ REGISTER_IN v4 [CDCDCDCD, CDCDCDCD, CDCDCDCD, CDCDCDCD]
   # vpkd3d128 v4, v3, 5, 2, 0
   .long 0x18961E10
   blr
-  #_ REGISTER_OUT v3 [3F000000, BF000000, 3F000000, BF000000]
-  #_ REGISTER_OUT v4 [CDCDCDCD, CDCDCDCD, 3800B800, 3800B800]
+  #_ REGISTER_OUT v3 [3F000000, BF000000, 3F800000, BF800000]
+  #_ REGISTER_OUT v4 [CDCDCDCD, CDCDCDCD, 3800B800, 3C00BC00]
diff --git a/src/xenia/cpu/ppc/testing/premake5.lua b/src/xenia/cpu/ppc/testing/premake5.lua
index 78874ecc4..d2d5549cd 100644
--- a/src/xenia/cpu/ppc/testing/premake5.lua
+++ b/src/xenia/cpu/ppc/testing/premake5.lua
@@ -13,6 +13,7 @@ project("xenia-cpu-ppc-tests")
     "xenia-base",
     "gflags",
     "capstone", -- cpu-backend-x64
+    "mspack",
   })
   files({
     "ppc_testing_main.cc",
diff --git a/src/xenia/cpu/premake5.lua b/src/xenia/cpu/premake5.lua
index 08fd41c0d..96a41f6e0 100644
--- a/src/xenia/cpu/premake5.lua
+++ b/src/xenia/cpu/premake5.lua
@@ -8,6 +8,7 @@ project("xenia-cpu")
   language("C++")
   links({
     "xenia-base",
+    "mspack",
   })
   includedirs({
     project_root.."/third_party/llvm/include",
diff --git a/src/xenia/cpu/stack_walker.h b/src/xenia/cpu/stack_walker.h
index d9cabaf6a..4dd4f44e9 100644
--- a/src/xenia/cpu/stack_walker.h
+++ b/src/xenia/cpu/stack_walker.h
@@ -92,6 +92,8 @@ class StackWalker {
   // populated.
   virtual bool ResolveStack(uint64_t* frame_host_pcs, StackFrame* frames,
                             size_t frame_count) = 0;
+
+  virtual ~StackWalker() = default;
 };
 
 }  // namespace cpu
diff --git a/src/xenia/cpu/xex_module.cc b/src/xenia/cpu/xex_module.cc
index 88a61b964..8f9e0be21 100644
--- a/src/xenia/cpu/xex_module.cc
+++ b/src/xenia/cpu/xex_module.cc
@@ -17,6 +17,7 @@
 #include "xenia/base/memory.h"
 #include "xenia/cpu/cpu_flags.h"
 #include "xenia/cpu/export_resolver.h"
+#include "xenia/cpu/lzx.h"
 #include "xenia/cpu/processor.h"
 #include "xenia/kernel/kernel_state.h"
 #include "xenia/kernel/xmodule.h"
@@ -24,9 +25,6 @@
 #include "third_party/crypto/TinySHA1.hpp"
 #include "third_party/crypto/rijndael-alg-fst.c"
 #include "third_party/crypto/rijndael-alg-fst.h"
-#include "third_party/mspack/lzx.h"
-#include "third_party/mspack/lzxd.c"
-#include "third_party/mspack/mspack.h"
 #include "third_party/pe/pe_image.h"
 
 static const uint8_t xe_xex2_retail_key[16] = {
@@ -36,165 +34,6 @@ static const uint8_t xe_xex2_devkit_key[16] = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-typedef struct mspack_memory_file_t {
-  struct mspack_system sys;
-  void* buffer;
-  off_t buffer_size;
-  off_t offset;
-} mspack_memory_file;
-mspack_memory_file* mspack_memory_open(struct mspack_system* sys, void* buffer,
-                                       const size_t buffer_size) {
-  assert_true(buffer_size < INT_MAX);
-  if (buffer_size >= INT_MAX) {
-    return NULL;
-  }
-  mspack_memory_file* memfile =
-      (mspack_memory_file*)calloc(1, sizeof(mspack_memory_file));
-  if (!memfile) {
-    return NULL;
-  }
-  memfile->buffer = buffer;
-  memfile->buffer_size = (off_t)buffer_size;
-  memfile->offset = 0;
-  return memfile;
-}
-void mspack_memory_close(mspack_memory_file* file) {
-  mspack_memory_file* memfile = (mspack_memory_file*)file;
-  free(memfile);
-}
-int mspack_memory_read(struct mspack_file* file, void* buffer, int chars) {
-  mspack_memory_file* memfile = (mspack_memory_file*)file;
-  const off_t remaining = memfile->buffer_size - memfile->offset;
-  const off_t total = std::min(static_cast<off_t>(chars), remaining);
-  memcpy(buffer, (uint8_t*)memfile->buffer + memfile->offset, total);
-  memfile->offset += total;
-  return (int)total;
-}
-int mspack_memory_write(struct mspack_file* file, void* buffer, int chars) {
-  mspack_memory_file* memfile = (mspack_memory_file*)file;
-  const off_t remaining = memfile->buffer_size - memfile->offset;
-  const off_t total = std::min(static_cast<off_t>(chars), remaining);
-  memcpy((uint8_t*)memfile->buffer + memfile->offset, buffer, total);
-  memfile->offset += total;
-  return (int)total;
-}
-void* mspack_memory_alloc(struct mspack_system* sys, size_t chars) {
-  return calloc(chars, 1);
-}
-void mspack_memory_free(void* ptr) { free(ptr); }
-void mspack_memory_copy(void* src, void* dest, size_t chars) {
-  memcpy(dest, src, chars);
-}
-struct mspack_system* mspack_memory_sys_create() {
-  struct mspack_system* sys =
-      (struct mspack_system*)calloc(1, sizeof(struct mspack_system));
-  if (!sys) {
-    return NULL;
-  }
-  sys->read = mspack_memory_read;
-  sys->write = mspack_memory_write;
-  sys->alloc = mspack_memory_alloc;
-  sys->free = mspack_memory_free;
-  sys->copy = mspack_memory_copy;
-  return sys;
-}
-void mspack_memory_sys_destroy(struct mspack_system* sys) { free(sys); }
-
-int lzx_decompress(const void* lzx_data, size_t lzx_len, void* dest,
-                   size_t dest_len, uint32_t window_size, void* window_data,
-                   size_t window_data_len) {
-  uint32_t window_bits = 0;
-  uint32_t temp_sz = window_size;
-  for (size_t m = 0; m < 32; m++, window_bits++) {
-    temp_sz >>= 1;
-    if (temp_sz == 0x00000000) {
-      break;
-    }
-  }
-
-  int result_code = 1;
-
-  mspack_system* sys = mspack_memory_sys_create();
-  mspack_memory_file* lzxsrc =
-      mspack_memory_open(sys, (void*)lzx_data, lzx_len);
-  mspack_memory_file* lzxdst = mspack_memory_open(sys, dest, dest_len);
-  lzxd_stream* lzxd =
-      lzxd_init(sys, (struct mspack_file*)lzxsrc, (struct mspack_file*)lzxdst,
-                window_bits, 0, 0x8000, (off_t)dest_len);
-
-  if (lzxd) {
-    if (window_data) {
-      // zero the window and then copy window_data to the end of it
-      memset(lzxd->window, 0, window_data_len);
-      memcpy(lzxd->window + (window_size - window_data_len), window_data,
-             window_data_len);
-    }
-
-    result_code = lzxd_decompress(lzxd, (off_t)dest_len);
-
-    lzxd_free(lzxd);
-    lzxd = NULL;
-  }
-  if (lzxsrc) {
-    mspack_memory_close(lzxsrc);
-    lzxsrc = NULL;
-  }
-  if (lzxdst) {
-    mspack_memory_close(lzxdst);
-    lzxdst = NULL;
-  }
-  if (sys) {
-    mspack_memory_sys_destroy(sys);
-    sys = NULL;
-  }
-
-  return result_code;
-}
-
-int lzxdelta_apply_patch(xe::xex2_delta_patch* patch, size_t patch_len,
-                         uint32_t window_size, void* dest) {
-  void* patch_end = (char*)patch + patch_len;
-  auto* cur_patch = patch;
-
-  while (patch_end > cur_patch) {
-    int patch_sz = -4;  // 0 byte patches need us to remove 4 byte from next
-                        // patch addr because of patch_data field
-    if (cur_patch->compressed_len == 0 && cur_patch->uncompressed_len == 0 &&
-        cur_patch->new_addr == 0 && cur_patch->old_addr == 0)
-      break;
-    switch (cur_patch->compressed_len) {
-      case 0:  // fill with 0
-        memset((char*)dest + cur_patch->new_addr, 0,
-               cur_patch->uncompressed_len);
-        break;
-      case 1:  // copy from old -> new
-        memcpy((char*)dest + cur_patch->new_addr,
-               (char*)dest + cur_patch->old_addr, cur_patch->uncompressed_len);
-        break;
-      default:  // delta patch
-        patch_sz =
-            cur_patch->compressed_len - 4;  // -4 because of patch_data field
-
-        int result = lzx_decompress(
-            cur_patch->patch_data, cur_patch->compressed_len,
-            (char*)dest + cur_patch->new_addr, cur_patch->uncompressed_len,
-            window_size, (char*)dest + cur_patch->old_addr,
-            cur_patch->uncompressed_len);
-
-        if (result) {
-          return result;
-        }
-        break;
-    }
-
-    cur_patch++;
-    cur_patch = (xe::xex2_delta_patch*)((char*)cur_patch +
-                                        patch_sz);  // TODO: make this less ugly
-  }
-
-  return 0;
-}
-
 void aes_decrypt_buffer(const uint8_t* session_key, const uint8_t* input_buffer,
                         const size_t input_size, uint8_t* output_buffer,
                         const size_t output_size) {
@@ -754,7 +593,7 @@ int XexModule::ReadImageBasicCompressed(const void* xex_addr,
     xex2_page_descriptor desc;
     desc.value = xe::byte_swap(xex_security_info()->page_descriptors[i].value);
 
-    total_size += desc.size * heap->page_size();
+    total_size += desc.page_count * heap->page_size();
   }
 
   // Allocate in-place the XEX memory.
@@ -831,7 +670,6 @@ int XexModule::ReadImageCompressed(const void* xex_addr, size_t xex_length) {
   uint8_t* compress_buffer = NULL;
   const uint8_t* p = NULL;
   uint8_t* d = NULL;
-  uint32_t uncompressed_size = 0;
   sha1::SHA1 s;
 
   // Decrypt (if needed).
@@ -895,8 +733,6 @@ int XexModule::ReadImageCompressed(const void* xex_addr, size_t xex_length) {
       memcpy(d, p, chunk_size);
       p += chunk_size;
       d += chunk_size;
-
-      uncompressed_size += 0x8000;
     }
 
     p = pnext;
@@ -904,6 +740,8 @@ int XexModule::ReadImageCompressed(const void* xex_addr, size_t xex_length) {
   }
 
   if (!result_code) {
+    uint32_t uncompressed_size = image_size();
+
     // Allocate in-place the XEX memory.
     bool alloc_result =
         memory()
@@ -1108,36 +946,36 @@ bool XexModule::LoadContinue() {
     desc.value = xe::byte_swap(sec_header->page_descriptors[i].value);
 
     const auto start_address = base_address_ + (page * page_size);
-    const auto end_address = start_address + (desc.size * page_size);
+    const auto end_address = start_address + (desc.page_count * page_size);
     if (desc.info == XEX_SECTION_CODE) {
       low_address_ = std::min(low_address_, start_address);
       high_address_ = std::max(high_address_, end_address);
     }
 
-    page += desc.size;
+    page += desc.page_count;
   }
 
   // Notify backend that we have an executable range.
   processor_->backend()->CommitExecutableRange(low_address_, high_address_);
 
   // Add all imports (variables/functions).
-  xex2_opt_import_libraries* opt_import_header = nullptr;
-  GetOptHeader(XEX_HEADER_IMPORT_LIBRARIES, &opt_import_header);
+  xex2_opt_import_libraries* opt_import_libraries = nullptr;
+  GetOptHeader(XEX_HEADER_IMPORT_LIBRARIES, &opt_import_libraries);
 
-  if (opt_import_header) {
+  if (opt_import_libraries) {
     // FIXME: Don't know if 32 is the actual limit, but haven't seen more than
     // 2.
     const char* string_table[32];
     std::memset(string_table, 0, sizeof(string_table));
-    size_t max_string_table_index = 0;
 
     // Parse the string table
-    for (size_t i = 0; i < opt_import_header->string_table_size;
-         ++max_string_table_index) {
-      assert_true(max_string_table_index < xe::countof(string_table));
-      const char* str = opt_import_header->string_table + i;
+    for (size_t i = 0, o = 0; i < opt_import_libraries->string_table.size &&
+                              o < opt_import_libraries->string_table.count;
+         ++o) {
+      assert_true(o < xe::countof(string_table));
+      const char* str = &opt_import_libraries->string_table.data[i];
 
-      string_table[max_string_table_index] = str;
+      string_table[o] = str;
       i += std::strlen(str) + 1;
 
       // Padding
@@ -1146,15 +984,18 @@ bool XexModule::LoadContinue() {
       }
     }
 
-    auto libraries_ptr = reinterpret_cast<uint8_t*>(opt_import_header) +
-                         opt_import_header->string_table_size + 12;
-    uint32_t library_offset = 0;
-    uint32_t library_count = opt_import_header->library_count;
-    for (uint32_t i = 0; i < library_count; i++) {
-      auto library = reinterpret_cast<xex2_import_library*>(libraries_ptr +
-                                                            library_offset);
+    auto library_data = reinterpret_cast<uint8_t*>(opt_import_libraries);
+    uint32_t library_offset = opt_import_libraries->string_table.size + 12;
+    while (library_offset < opt_import_libraries->size) {
+      auto library =
+          reinterpret_cast<xex2_import_library*>(library_data + library_offset);
+      if (!library->size) {
+        break;
+      }
       size_t library_name_index = library->name_index & 0xFF;
-      assert_true(library_name_index < max_string_table_index);
+      assert_true(library_name_index <
+                  opt_import_libraries->string_table.count);
+      assert_not_null(string_table[library_name_index]);
       SetupLibraryImports(string_table[library_name_index], library);
       library_offset += library->size;
     }
@@ -1180,7 +1021,7 @@ bool XexModule::LoadContinue() {
     desc.value = xe::byte_swap(sec_header->page_descriptors[i].value);
 
     auto address = base_address_ + (page * page_size);
-    auto size = desc.size * page_size;
+    auto size = desc.page_count * page_size;
     switch (desc.info) {
       case XEX_SECTION_CODE:
       case XEX_SECTION_READONLY_DATA:
@@ -1191,7 +1032,7 @@ bool XexModule::LoadContinue() {
         break;
     }
 
-    page += desc.size;
+    page += desc.page_count;
   }
 
   return true;
@@ -1314,10 +1155,12 @@ bool XexModule::SetupLibraryImports(const char* name,
       var_info->set_status(Symbol::Status::kDefined);
     } else if (record_type == 1) {
       // Thunk.
-      assert_true(library_info.imports.size() > 0);
-      auto& prev_import = library_info.imports[library_info.imports.size() - 1];
-      assert_true(prev_import.ordinal == ordinal);
-      prev_import.thunk_address = record_addr;
+      if (library_info.imports.size() > 0) {
+        auto& prev_import =
+            library_info.imports[library_info.imports.size() - 1];
+        assert_true(prev_import.ordinal == ordinal);
+        prev_import.thunk_address = record_addr;
+      }
 
       if (kernel_export) {
         import_name.AppendFormat("%s", kernel_export->name);
@@ -1576,12 +1419,14 @@ bool XexModule::FindSaveRest() {
   auto page_size = base_address_ <= 0x90000000 ? 64 * 1024 : 4 * 1024;
   auto sec_header = xex_security_info();
   for (uint32_t i = 0, page = 0; i < sec_header->page_descriptor_count; i++) {
-    const xex2_page_descriptor* section =
-        &xex_security_info()->page_descriptors[i];
-    const auto start_address = base_address_ + (page * page_size);
-    const auto end_address = start_address + (section->size * page_size);
+    // Byteswap the bitfield manually.
+    xex2_page_descriptor desc;
+    desc.value = xe::byte_swap(sec_header->page_descriptors[i].value);
 
-    if (section->info == XEX_SECTION_CODE) {
+    const auto start_address = base_address_ + (page * page_size);
+    const auto end_address = start_address + (desc.page_count * page_size);
+
+    if (desc.info == XEX_SECTION_CODE) {
       if (!gplr_start) {
         gplr_start = memory_->SearchAligned(start_address, end_address,
                                             gprlr_code_values,
@@ -1602,7 +1447,7 @@ bool XexModule::FindSaveRest() {
       }
     }
 
-    page += section->size;
+    page += desc.page_count;
   }
 
   // Add function stubs.
diff --git a/src/xenia/cpu/xex_module.h b/src/xenia/cpu/xex_module.h
index d9d1996de..5c8cb8d6b 100644
--- a/src/xenia/cpu/xex_module.h
+++ b/src/xenia/cpu/xex_module.h
@@ -67,7 +67,7 @@ class XexModule : public xe::cpu::Module {
       desc.value =
           xe::byte_swap(xex_security_info()->page_descriptors[i].value);
 
-      total_size += desc.size * heap->page_size();
+      total_size += desc.page_count * heap->page_size();
     }
     return total_size;
   }
diff --git a/src/xenia/emulator.cc b/src/xenia/emulator.cc
index 19a82a85e..8030a8078 100644
--- a/src/xenia/emulator.cc
+++ b/src/xenia/emulator.cc
@@ -48,8 +48,9 @@ DEFINE_double(time_scalar, 1.0,
 
 namespace xe {
 
-Emulator::Emulator(const std::wstring& command_line)
-    : command_line_(command_line) {}
+Emulator::Emulator(const std::wstring& command_line,
+                   const std::wstring& content_root)
+    : command_line_(command_line), content_root_(content_root) {}
 
 Emulator::~Emulator() {
   // Note that we delete things in the reverse order they were initialized.
diff --git a/src/xenia/emulator.h b/src/xenia/emulator.h
index 4492419e7..a60b4e2e7 100644
--- a/src/xenia/emulator.h
+++ b/src/xenia/emulator.h
@@ -47,12 +47,16 @@ namespace xe {
 // This is responsible for initializing and managing all the various subsystems.
 class Emulator {
  public:
-  explicit Emulator(const std::wstring& command_line);
+  explicit Emulator(const std::wstring& command_line,
+                    const std::wstring& content_root);
   ~Emulator();
 
   // Full command line used when launching the process.
   const std::wstring& command_line() const { return command_line_; }
 
+  // Folder content is stored in.
+  const std::wstring& content_root() const { return content_root_; }
+
   // Title of the game in the default language.
   const std::wstring& game_title() const { return game_title_; }
 
@@ -154,6 +158,8 @@ class Emulator {
                           const std::string& module_path);
 
   std::wstring command_line_;
+  std::wstring content_root_;
+
   std::wstring game_title_;
 
   ui::Window* display_window_;
diff --git a/src/xenia/gpu/command_processor.cc b/src/xenia/gpu/command_processor.cc
index 944170dfd..1f7e36748 100644
--- a/src/xenia/gpu/command_processor.cc
+++ b/src/xenia/gpu/command_processor.cc
@@ -347,8 +347,8 @@ void CommandProcessor::MakeCoherent() {
   // some way to check for dest coherency (what all the COHER_DEST_BASE_*
   // registers are for).
   // Best docs I've found on this are here:
-  // http://amd-dev.wpengine.netdna-cdn.com/wordpress/media/2013/10/R6xx_R7xx_3D.pdf
-  // http://cgit.freedesktop.org/xorg/driver/xf86-video-radeonhd/tree/src/r6xx_accel.c?id=3f8b6eccd9dba116cc4801e7f80ce21a879c67d2#n454
+  // https://web.archive.org/web/20160711162346/https://amd-dev.wpengine.netdna-cdn.com/wordpress/media/2013/10/R6xx_R7xx_3D.pdf
+  // https://cgit.freedesktop.org/xorg/driver/xf86-video-radeonhd/tree/src/r6xx_accel.c?id=3f8b6eccd9dba116cc4801e7f80ce21a879c67d2#n454
 
   RegisterFile* regs = register_file_;
   auto status_host = regs->values[XE_GPU_REG_COHER_STATUS_HOST].u32;
@@ -360,7 +360,7 @@ void CommandProcessor::MakeCoherent() {
   }
 
   const char* action = "N/A";
-  if (status_host & 0x03000000) {
+  if ((status_host & 0x03000000) == 0x03000000) {
     action = "VC | TC";
   } else if (status_host & 0x02000000) {
     action = "TC";
@@ -1392,7 +1392,7 @@ bool CommandProcessor::ExecutePacketType3_VIZ_QUERY(RingBuffer* reader,
                                                     uint32_t packet,
                                                     uint32_t count) {
   // begin/end initiator for viz query extent processing
-  // http://www.google.com/patents/US20050195186
+  // https://www.google.com/patents/US20050195186
   assert_true(count == 1);
 
   uint32_t dword0 = reader->ReadAndSwap<uint32_t>();
diff --git a/src/xenia/gpu/glsl_shader_translator.cc b/src/xenia/gpu/glsl_shader_translator.cc
index 32d26c1a2..e1e8baff4 100644
--- a/src/xenia/gpu/glsl_shader_translator.cc
+++ b/src/xenia/gpu/glsl_shader_translator.cc
@@ -131,8 +131,8 @@ struct VertexData {
 };
 )");
 
-  // http://www.nvidia.com/object/cube_map_ogl_tutorial.html
-  // http://developer.amd.com/wordpress/media/2012/10/R600_Instruction_Set_Architecture.pdf
+  // https://www.nvidia.com/object/cube_map_ogl_tutorial.html
+  // https://developer.amd.com/wordpress/media/2012/10/R600_Instruction_Set_Architecture.pdf
   // src0 = Rn.zzxy, src1 = Rn.yxzz
   // dst.W = FaceId;
   // dst.Z = 2.0f * MajorAxis;
diff --git a/src/xenia/gpu/graphics_system.cc b/src/xenia/gpu/graphics_system.cc
index 3a60bc939..6431edfab 100644
--- a/src/xenia/gpu/graphics_system.cc
+++ b/src/xenia/gpu/graphics_system.cc
@@ -26,8 +26,8 @@ namespace gpu {
 // Nvidia Optimus/AMD PowerXpress support.
 // These exports force the process to trigger the discrete GPU in multi-GPU
 // systems.
-// http://developer.download.nvidia.com/devzone/devcenter/gamegraphics/files/OptimusRenderingPolicies.pdf
-// http://stackoverflow.com/questions/17458803/amd-equivalent-to-nvoptimusenablement
+// https://developer.download.nvidia.com/devzone/devcenter/gamegraphics/files/OptimusRenderingPolicies.pdf
+// https://stackoverflow.com/questions/17458803/amd-equivalent-to-nvoptimusenablement
 #if XE_PLATFORM_WIN32
 extern "C" {
 __declspec(dllexport) uint32_t NvOptimusEnablement = 0x00000001;
@@ -74,7 +74,7 @@ X_STATUS GraphicsSystem::Setup(cpu::Processor* processor,
           "Ensure you have the latest drivers for your GPU and "
           "that it supports Vulkan.\n"
           "\n"
-          "See http://xenia.jp/faq/ for more information and a list of "
+          "See https://xenia.jp/faq/ for more information and a list of "
           "supported GPUs.");
       return X_STATUS_UNSUCCESSFUL;
     }
diff --git a/src/xenia/gpu/shader_translator.cc b/src/xenia/gpu/shader_translator.cc
index c01309b3f..fc06fc0de 100644
--- a/src/xenia/gpu/shader_translator.cc
+++ b/src/xenia/gpu/shader_translator.cc
@@ -40,7 +40,7 @@ using namespace ucode;
 // https://github.com/freedreno/freedreno/blob/master/util/disasm-a2xx.c
 //
 // Lots of naming comes from the disassembly spit out by the XNA GS compiler
-// and dumps of d3dcompiler and games: http://pastebin.com/i4kAv7bB
+// and dumps of d3dcompiler and games: https://pastebin.com/i4kAv7bB
 
 ShaderTranslator::ShaderTranslator() = default;
 
@@ -1074,7 +1074,7 @@ void ParseAluInstructionOperand(const AluInstruction& op, int i,
   out_op->component_count = swizzle_component_count;
   uint32_t swizzle = op.src_swizzle(i);
   if (swizzle_component_count == 1) {
-    uint32_t a = swizzle & 0x3;
+    uint32_t a = ((swizzle >> 6) + 3) & 0x3;
     out_op->components[0] = GetSwizzleFromComponentIndex(a);
   } else if (swizzle_component_count == 2) {
     uint32_t a = ((swizzle >> 6) + 3) & 0x3;
@@ -1100,6 +1100,7 @@ void ParseAluInstructionOperandSpecial(const AluInstruction& op,
   out_op->storage_source = storage_source;
   if (storage_source == InstructionStorageSource::kRegister) {
     out_op->storage_index = reg & 0x7F;
+    out_op->storage_addressing_mode = InstructionStorageAddressingMode::kStatic;
   } else {
     out_op->storage_index = reg;
     if ((const_slot == 0 && op.is_const_0_addressed()) ||
diff --git a/src/xenia/gpu/texture_conversion.cc b/src/xenia/gpu/texture_conversion.cc
index 3e238238b..2ba20d976 100644
--- a/src/xenia/gpu/texture_conversion.cc
+++ b/src/xenia/gpu/texture_conversion.cc
@@ -48,7 +48,7 @@ void CopySwapBlock(Endian endian, void* output, const void* input,
 
 void ConvertTexelCTX1ToR8G8(Endian endian, void* output, const void* input,
                             size_t length) {
-  // http://fileadmin.cs.lth.se/cs/Personal/Michael_Doggett/talks/unc-xenos-doggett.pdf
+  // https://fileadmin.cs.lth.se/cs/Personal/Michael_Doggett/talks/unc-xenos-doggett.pdf
   union {
     uint8_t data[8];
     struct {
diff --git a/src/xenia/gpu/texture_info.cc b/src/xenia/gpu/texture_info.cc
index 81efe57c1..85e88e45c 100644
--- a/src/xenia/gpu/texture_info.cc
+++ b/src/xenia/gpu/texture_info.cc
@@ -26,7 +26,7 @@ using namespace xe::gpu::xenos;
 
 bool TextureInfo::Prepare(const xe_gpu_texture_fetch_t& fetch,
                           TextureInfo* out_info) {
-  // http://msdn.microsoft.com/en-us/library/windows/desktop/cc308051(v=vs.85).aspx
+  // https://msdn.microsoft.com/en-us/library/windows/desktop/cc308051(v=vs.85).aspx
   // a2xx_sq_surfaceformat
 
   std::memset(out_info, 0, sizeof(TextureInfo));
diff --git a/src/xenia/gpu/texture_info.h b/src/xenia/gpu/texture_info.h
index 03ab78fd9..c50fd0a8d 100644
--- a/src/xenia/gpu/texture_info.h
+++ b/src/xenia/gpu/texture_info.h
@@ -230,8 +230,10 @@ inline TextureFormat ColorRenderTargetToTextureFormat(
     case ColorRenderTargetFormat::k_8_8_8_8_GAMMA:
       return TextureFormat::k_8_8_8_8_GAMMA_EDRAM;
     case ColorRenderTargetFormat::k_2_10_10_10:
+    case ColorRenderTargetFormat::k_2_10_10_10_AS_10_10_10_10:
       return TextureFormat::k_2_10_10_10;
     case ColorRenderTargetFormat::k_2_10_10_10_FLOAT:
+    case ColorRenderTargetFormat::k_2_10_10_10_FLOAT_AS_16_16_16_16:
       return TextureFormat::k_2_10_10_10_FLOAT_EDRAM;
     case ColorRenderTargetFormat::k_16_16:
       return TextureFormat::k_16_16_EDRAM;
@@ -241,10 +243,6 @@ inline TextureFormat ColorRenderTargetToTextureFormat(
       return TextureFormat::k_16_16_FLOAT;
     case ColorRenderTargetFormat::k_16_16_16_16_FLOAT:
       return TextureFormat::k_16_16_16_16_FLOAT;
-    case ColorRenderTargetFormat::k_2_10_10_10_AS_16_16_16_16:
-      return TextureFormat::k_2_10_10_10_AS_16_16_16_16;
-    case ColorRenderTargetFormat::k_2_10_10_10_FLOAT_AS_16_16_16_16:
-      return TextureFormat::k_2_10_10_10_FLOAT_EDRAM;
     case ColorRenderTargetFormat::k_32_FLOAT:
       return TextureFormat::k_32_FLOAT;
     case ColorRenderTargetFormat::k_32_32_FLOAT:
diff --git a/src/xenia/gpu/trace_dump.cc b/src/xenia/gpu/trace_dump.cc
index 8c3de28be..66df289b7 100644
--- a/src/xenia/gpu/trace_dump.cc
+++ b/src/xenia/gpu/trace_dump.cc
@@ -103,7 +103,7 @@ int TraceDump::Main(const std::vector<std::wstring>& args) {
 
 bool TraceDump::Setup() {
   // Create the emulator but don't initialize so we can setup the window.
-  emulator_ = std::make_unique<Emulator>(L"");
+  emulator_ = std::make_unique<Emulator>(L"", L"");
   X_STATUS result = emulator_->Setup(
       nullptr, nullptr, [this]() { return CreateGraphicsSystem(); }, nullptr);
   if (XFAILED(result)) {
diff --git a/src/xenia/gpu/trace_viewer.cc b/src/xenia/gpu/trace_viewer.cc
index 4e08e7081..1a3ccb951 100644
--- a/src/xenia/gpu/trace_viewer.cc
+++ b/src/xenia/gpu/trace_viewer.cc
@@ -122,7 +122,7 @@ bool TraceViewer::Setup() {
   window_->Resize(1920, 1200);
 
   // Create the emulator but don't initialize so we can setup the window.
-  emulator_ = std::make_unique<Emulator>(L"");
+  emulator_ = std::make_unique<Emulator>(L"", L"");
   X_STATUS result =
       emulator_->Setup(window_.get(), nullptr,
                        [this]() { return CreateGraphicsSystem(); }, nullptr);
@@ -990,7 +990,7 @@ static const char* kColorFormatNames[] = {
     /* 7  */ "k_16_16_16_16_FLOAT",
     /* 8  */ "unknown(8)",
     /* 9  */ "unknown(9)",
-    /* 10 */ "k_2_10_10_10_AS_16_16_16_16",
+    /* 10 */ "k_2_10_10_10_AS_10_10_10_10",
     /* 11 */ "unknown(11)",
     /* 12 */ "k_2_10_10_10_FLOAT_AS_16_16_16_16",
     /* 13 */ "unknown(13)",
diff --git a/src/xenia/gpu/ucode.h b/src/xenia/gpu/ucode.h
index e4487c405..9d2df4166 100644
--- a/src/xenia/gpu/ucode.h
+++ b/src/xenia/gpu/ucode.h
@@ -17,7 +17,7 @@
 #include "xenia/gpu/xenos.h"
 
 // Closest AMD doc:
-// http://developer.amd.com/wordpress/media/2012/10/R600_Instruction_Set_Architecture.pdf
+// https://developer.amd.com/wordpress/media/2012/10/R600_Instruction_Set_Architecture.pdf
 // Microcode format differs, but most fields/enums are the same.
 
 // This code comes from the freedreno project:
@@ -701,7 +701,7 @@ static_assert_size(TextureFetchInstruction, 12);
 // R600 docs that have a near 1:1 with the instructions available in the xenos
 // GPU. Some of the behavior has been experimentally verified. Some has been
 // guessed.
-// Docs: http://www.x.org/docs/AMD/old/r600isa.pdf
+// Docs: https://www.x.org/docs/AMD/old/r600isa.pdf
 //
 // Conventions:
 // - All temporary registers are vec4s.
diff --git a/src/xenia/gpu/vulkan/pipeline_cache.cc b/src/xenia/gpu/vulkan/pipeline_cache.cc
index d89e46af9..9a7eabcd0 100644
--- a/src/xenia/gpu/vulkan/pipeline_cache.cc
+++ b/src/xenia/gpu/vulkan/pipeline_cache.cc
@@ -660,7 +660,7 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer,
   }
 
   // Whether each of the viewport settings are enabled.
-  // http://www.x.org/docs/AMD/old/evergreen_3D_registers_v2.pdf
+  // https://www.x.org/docs/AMD/old/evergreen_3D_registers_v2.pdf
   bool vport_xscale_enable = (regs.pa_cl_vte_cntl & (1 << 0)) > 0;
   bool vport_xoffset_enable = (regs.pa_cl_vte_cntl & (1 << 1)) > 0;
   bool vport_yscale_enable = (regs.pa_cl_vte_cntl & (1 << 2)) > 0;
@@ -865,7 +865,7 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer,
       push_constants.window_scale[3] = (-1280.f / window_height_scalar) + 0.5f;
     }
 
-    // http://www.x.org/docs/AMD/old/evergreen_3D_registers_v2.pdf
+    // https://www.x.org/docs/AMD/old/evergreen_3D_registers_v2.pdf
     // VTX_XY_FMT = true: the incoming XY have already been multiplied by 1/W0.
     //            = false: multiply the X, Y coordinates by 1/W0.
     // VTX_Z_FMT = true: the incoming Z has already been multiplied by 1/W0.
diff --git a/src/xenia/gpu/vulkan/premake5.lua b/src/xenia/gpu/vulkan/premake5.lua
index b399914a8..f8e9903fe 100644
--- a/src/xenia/gpu/vulkan/premake5.lua
+++ b/src/xenia/gpu/vulkan/premake5.lua
@@ -38,6 +38,7 @@ project("xenia-gpu-vulkan-trace-viewer")
     "imgui",
     "libavcodec",
     "libavutil",
+    "mspack",
     "snappy",
     "spirv-tools",
     "volk",
@@ -110,6 +111,7 @@ project("xenia-gpu-vulkan-trace-dump")
     "imgui",
     "libavcodec",
     "libavutil",
+    "mspack",
     "snappy",
     "spirv-tools",
     "volk",
diff --git a/src/xenia/gpu/vulkan/render_cache.cc b/src/xenia/gpu/vulkan/render_cache.cc
index 8e3ae93d1..075fd54ab 100644
--- a/src/xenia/gpu/vulkan/render_cache.cc
+++ b/src/xenia/gpu/vulkan/render_cache.cc
@@ -32,7 +32,7 @@ ColorRenderTargetFormat GetBaseRTFormat(ColorRenderTargetFormat format) {
   switch (format) {
     case ColorRenderTargetFormat::k_8_8_8_8_GAMMA:
       return ColorRenderTargetFormat::k_8_8_8_8;
-    case ColorRenderTargetFormat::k_2_10_10_10_AS_16_16_16_16:
+    case ColorRenderTargetFormat::k_2_10_10_10_AS_10_10_10_10:
       return ColorRenderTargetFormat::k_2_10_10_10;
     case ColorRenderTargetFormat::k_2_10_10_10_FLOAT_AS_16_16_16_16:
       return ColorRenderTargetFormat::k_2_10_10_10_FLOAT;
@@ -47,7 +47,7 @@ VkFormat ColorRenderTargetFormatToVkFormat(ColorRenderTargetFormat format) {
     case ColorRenderTargetFormat::k_8_8_8_8_GAMMA:
       return VK_FORMAT_R8G8B8A8_UNORM;
     case ColorRenderTargetFormat::k_2_10_10_10:
-    case ColorRenderTargetFormat::k_2_10_10_10_AS_16_16_16_16:
+    case ColorRenderTargetFormat::k_2_10_10_10_AS_10_10_10_10:
       return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
     case ColorRenderTargetFormat::k_2_10_10_10_FLOAT:
     case ColorRenderTargetFormat::k_2_10_10_10_FLOAT_AS_16_16_16_16:
@@ -786,7 +786,7 @@ bool RenderCache::ParseConfiguration(RenderConfiguration* config) {
   config->mode_control = regs.rb_modecontrol.edram_mode;
 
   // RB_SURFACE_INFO
-  // http://fossies.org/dox/MesaLib-10.3.5/fd2__gmem_8c_source.html
+  // https://fossies.org/dox/MesaLib-10.3.5/fd2__gmem_8c_source.html
   config->surface_pitch_px = regs.rb_surface_info.surface_pitch;
   config->surface_msaa = regs.rb_surface_info.msaa_samples;
 
diff --git a/src/xenia/gpu/vulkan/shaders/bin/dummy_frag.h b/src/xenia/gpu/vulkan/shaders/bin/dummy_frag.h
index 0c321e8f7..7bcf6bc90 100644
--- a/src/xenia/gpu/vulkan/shaders/bin/dummy_frag.h
+++ b/src/xenia/gpu/vulkan/shaders/bin/dummy_frag.h
@@ -21,143 +21,30 @@ const uint8_t dummy_frag[] = {
     0x52, 0x42, 0x5F, 0x73, 0x68, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x5F, 0x6C,
     0x61, 0x6E, 0x67, 0x75, 0x61, 0x67, 0x65, 0x5F, 0x34, 0x32, 0x30, 0x70,
     0x61, 0x63, 0x6B, 0x00, 0x05, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00,
-    0x6D, 0x61, 0x69, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x73, 0x5F, 0x74,
-    0x79, 0x70, 0x65, 0x00, 0x06, 0x00, 0x07, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x66, 0x6C, 0x6F, 0x61, 0x74, 0x5F, 0x63, 0x6F,
-    0x6E, 0x73, 0x74, 0x73, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x6C, 0x6F, 0x6F, 0x70,
-    0x5F, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x73, 0x00, 0x06, 0x00, 0x06, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x62, 0x6F, 0x6F, 0x6C,
-    0x5F, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x73, 0x00, 0x05, 0x00, 0x04, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x73, 0x00, 0x00,
-    0x05, 0x00, 0x07, 0x00, 0x13, 0x00, 0x00, 0x00, 0x70, 0x75, 0x73, 0x68,
-    0x5F, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x73, 0x5F, 0x74, 0x79, 0x70, 0x65,
-    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x07, 0x00, 0x13, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x77, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x5F, 0x73,
-    0x63, 0x61, 0x6C, 0x65, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x05, 0x00,
-    0x13, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x76, 0x74, 0x78, 0x5F,
-    0x66, 0x6D, 0x74, 0x00, 0x06, 0x00, 0x06, 0x00, 0x13, 0x00, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x5F, 0x73, 0x69,
-    0x7A, 0x65, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00, 0x13, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x61, 0x6C, 0x70, 0x68, 0x61, 0x5F, 0x74, 0x65,
-    0x73, 0x74, 0x00, 0x00, 0x06, 0x00, 0x07, 0x00, 0x13, 0x00, 0x00, 0x00,
-    0x04, 0x00, 0x00, 0x00, 0x70, 0x73, 0x5F, 0x70, 0x61, 0x72, 0x61, 0x6D,
-    0x5F, 0x67, 0x65, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00,
-    0x15, 0x00, 0x00, 0x00, 0x70, 0x75, 0x73, 0x68, 0x5F, 0x63, 0x6F, 0x6E,
-    0x73, 0x74, 0x61, 0x6E, 0x74, 0x73, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00,
-    0x1A, 0x00, 0x00, 0x00, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x73,
-    0x31, 0x44, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x1F, 0x00, 0x00, 0x00,
-    0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x73, 0x32, 0x44, 0x00, 0x00,
-    0x05, 0x00, 0x05, 0x00, 0x24, 0x00, 0x00, 0x00, 0x74, 0x65, 0x78, 0x74,
-    0x75, 0x72, 0x65, 0x73, 0x33, 0x44, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00,
-    0x29, 0x00, 0x00, 0x00, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x73,
-    0x34, 0x44, 0x00, 0x00, 0x05, 0x00, 0x07, 0x00, 0x2D, 0x00, 0x00, 0x00,
-    0x69, 0x6E, 0x5F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x6F, 0x6C, 0x61,
-    0x74, 0x6F, 0x72, 0x73, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00,
-    0x31, 0x00, 0x00, 0x00, 0x6F, 0x43, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x0B, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x47, 0x00, 0x04, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
-    0x48, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x23, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x47, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x13, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x05, 0x00, 0x13, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x23, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
-    0x13, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x13, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x05, 0x00, 0x13, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-    0x23, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00,
-    0x13, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x1A, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x47, 0x00, 0x04, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x1F, 0x00, 0x00, 0x00,
-    0x22, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x1F, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x47, 0x00, 0x04, 0x00, 0x24, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x24, 0x00, 0x00, 0x00,
-    0x21, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x29, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x47, 0x00, 0x04, 0x00, 0x29, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x2D, 0x00, 0x00, 0x00,
-    0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x31, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-    0x15, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00,
-    0x0B, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x0D, 0x00, 0x00, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x0B, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x07, 0x00,
-    0x13, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x13, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00,
-    0x15, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x19, 0x00, 0x09, 0x00,
-    0x16, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x03, 0x00,
-    0x17, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x19, 0x00, 0x00, 0x00,
-    0x1A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x09, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x03, 0x00,
-    0x1C, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00,
-    0x1D, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x1D, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x1E, 0x00, 0x00, 0x00,
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x09, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x03, 0x00,
-    0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00,
-    0x22, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x22, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x23, 0x00, 0x00, 0x00,
-    0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x09, 0x00,
-    0x25, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x03, 0x00,
-    0x26, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00,
-    0x27, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x27, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x28, 0x00, 0x00, 0x00,
-    0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x04, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x2A, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x2C, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x2C, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00,
-    0x04, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x2F, 0x00, 0x00, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-    0x30, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00,
-    0x3B, 0x00, 0x04, 0x00, 0x30, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0xF8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00, 0xFD, 0x00, 0x01, 0x00,
-    0x38, 0x00, 0x01, 0x00,
+    0x6D, 0x61, 0x69, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x07, 0x00,
+    0x2D, 0x00, 0x00, 0x00, 0x69, 0x6E, 0x5F, 0x69, 0x6E, 0x74, 0x65, 0x72,
+    0x70, 0x6F, 0x6C, 0x61, 0x74, 0x6F, 0x72, 0x73, 0x00, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x03, 0x00, 0x31, 0x00, 0x00, 0x00, 0x6F, 0x43, 0x00, 0x00,
+    0x47, 0x00, 0x04, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x31, 0x00, 0x00, 0x00,
+    0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00,
+    0x09, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x2B, 0x00, 0x00, 0x00,
+    0x08, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x2C, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x04, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x2E, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00,
+    0x2F, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x04, 0x00, 0x30, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x2F, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x31, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0xFD, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00,
 };
diff --git a/src/xenia/gpu/vulkan/shaders/bin/dummy_frag.txt b/src/xenia/gpu/vulkan/shaders/bin/dummy_frag.txt
index c7c429294..33d1d9990 100644
--- a/src/xenia/gpu/vulkan/shaders/bin/dummy_frag.txt
+++ b/src/xenia/gpu/vulkan/shaders/bin/dummy_frag.txt
@@ -14,47 +14,8 @@
                OpSourceExtension "GL_ARB_separate_shader_objects"
                OpSourceExtension "GL_ARB_shading_language_420pack"
                OpName %main "main"
-               OpName %consts_type "consts_type"
-               OpMemberName %consts_type 0 "float_consts"
-               OpMemberName %consts_type 1 "loop_consts"
-               OpMemberName %consts_type 2 "bool_consts"
-               OpName %consts "consts"
-               OpName %push_consts_type "push_consts_type"
-               OpMemberName %push_consts_type 0 "window_scale"
-               OpMemberName %push_consts_type 1 "vtx_fmt"
-               OpMemberName %push_consts_type 2 "point_size"
-               OpMemberName %push_consts_type 3 "alpha_test"
-               OpMemberName %push_consts_type 4 "ps_param_gen"
-               OpName %push_constants "push_constants"
-               OpName %textures1D "textures1D"
-               OpName %textures2D "textures2D"
-               OpName %textures3D "textures3D"
-               OpName %textures4D "textures4D"
                OpName %in_interpolators "in_interpolators"
                OpName %oC "oC"
-               OpDecorate %_arr_v4float_uint_512 ArrayStride 16
-               OpDecorate %_arr_uint_uint_32 ArrayStride 16
-               OpDecorate %_arr_uint_uint_8 ArrayStride 16
-               OpMemberDecorate %consts_type 0 Offset 0
-               OpMemberDecorate %consts_type 1 Offset 8192
-               OpMemberDecorate %consts_type 2 Offset 8704
-               OpDecorate %consts_type Block
-               OpDecorate %consts DescriptorSet 0
-               OpDecorate %consts Binding 1
-               OpMemberDecorate %push_consts_type 0 Offset 0
-               OpMemberDecorate %push_consts_type 1 Offset 16
-               OpMemberDecorate %push_consts_type 2 Offset 32
-               OpMemberDecorate %push_consts_type 3 Offset 48
-               OpMemberDecorate %push_consts_type 4 Offset 64
-               OpDecorate %push_consts_type Block
-               OpDecorate %textures1D DescriptorSet 1
-               OpDecorate %textures1D Binding 0
-               OpDecorate %textures2D DescriptorSet 1
-               OpDecorate %textures2D Binding 1
-               OpDecorate %textures3D DescriptorSet 1
-               OpDecorate %textures3D Binding 2
-               OpDecorate %textures4D DescriptorSet 1
-               OpDecorate %textures4D Binding 3
                OpDecorate %in_interpolators Location 0
                OpDecorate %oC Location 0
        %void = OpTypeVoid
@@ -62,38 +23,6 @@
       %float = OpTypeFloat 32
     %v4float = OpTypeVector %float 4
        %uint = OpTypeInt 32 0
-   %uint_512 = OpConstant %uint 512
-%_arr_v4float_uint_512 = OpTypeArray %v4float %uint_512
-    %uint_32 = OpConstant %uint 32
-%_arr_uint_uint_32 = OpTypeArray %uint %uint_32
-     %uint_8 = OpConstant %uint 8
-%_arr_uint_uint_8 = OpTypeArray %uint %uint_8
-%consts_type = OpTypeStruct %_arr_v4float_uint_512 %_arr_uint_uint_32 %_arr_uint_uint_8
-%_ptr_Uniform_consts_type = OpTypePointer Uniform %consts_type
-     %consts = OpVariable %_ptr_Uniform_consts_type Uniform
-%push_consts_type = OpTypeStruct %v4float %v4float %v4float %v4float %uint
-%_ptr_PushConstant_push_consts_type = OpTypePointer PushConstant %push_consts_type
-%push_constants = OpVariable %_ptr_PushConstant_push_consts_type PushConstant
-         %22 = OpTypeImage %float 1D 0 0 0 1 Unknown
-         %23 = OpTypeSampledImage %22
-%_arr_23_uint_32 = OpTypeArray %23 %uint_32
-%_ptr_UniformConstant__arr_23_uint_32 = OpTypePointer UniformConstant %_arr_23_uint_32
- %textures1D = OpVariable %_ptr_UniformConstant__arr_23_uint_32 UniformConstant
-         %27 = OpTypeImage %float 2D 0 0 0 1 Unknown
-         %28 = OpTypeSampledImage %27
-%_arr_28_uint_32 = OpTypeArray %28 %uint_32
-%_ptr_UniformConstant__arr_28_uint_32 = OpTypePointer UniformConstant %_arr_28_uint_32
- %textures2D = OpVariable %_ptr_UniformConstant__arr_28_uint_32 UniformConstant
-         %32 = OpTypeImage %float 3D 0 0 0 1 Unknown
-         %33 = OpTypeSampledImage %32
-%_arr_33_uint_32 = OpTypeArray %33 %uint_32
-%_ptr_UniformConstant__arr_33_uint_32 = OpTypePointer UniformConstant %_arr_33_uint_32
- %textures3D = OpVariable %_ptr_UniformConstant__arr_33_uint_32 UniformConstant
-         %37 = OpTypeImage %float Cube 0 0 0 1 Unknown
-         %38 = OpTypeSampledImage %37
-%_arr_38_uint_32 = OpTypeArray %38 %uint_32
-%_ptr_UniformConstant__arr_38_uint_32 = OpTypePointer UniformConstant %_arr_38_uint_32
- %textures4D = OpVariable %_ptr_UniformConstant__arr_38_uint_32 UniformConstant
     %uint_16 = OpConstant %uint 16
 %_arr_v4float_uint_16 = OpTypeArray %v4float %uint_16
 %_ptr_Input__arr_v4float_uint_16 = OpTypePointer Input %_arr_v4float_uint_16
diff --git a/src/xenia/gpu/vulkan/shaders/bin/line_quad_list_geom.h b/src/xenia/gpu/vulkan/shaders/bin/line_quad_list_geom.h
index d5046f860..28935cc4a 100644
--- a/src/xenia/gpu/vulkan/shaders/bin/line_quad_list_geom.h
+++ b/src/xenia/gpu/vulkan/shaders/bin/line_quad_list_geom.h
@@ -139,68 +139,45 @@ const uint8_t line_quad_list_geom[] = {
     0xDA, 0x00, 0x01, 0x00, 0x41, 0x00, 0x06, 0x00, 0x13, 0x00, 0x00, 0x00,
     0x28, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
     0x0C, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x29, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x16, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
-    0x0C, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x2A, 0x00, 0x00, 0x00,
-    0x29, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x19, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x2C, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x1C, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x2D, 0x00, 0x00, 0x00,
-    0x2C, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x25, 0x00, 0x00, 0x00,
-    0x2E, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00,
-    0x2E, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x21, 0x00, 0x00, 0x00,
-    0x2F, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x13, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
-    0x30, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00,
-    0x0A, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x33, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
+    0x29, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x05, 0x00, 0x25, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00,
+    0x24, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x1F, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x21, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00,
+    0xDA, 0x00, 0x01, 0x00, 0x41, 0x00, 0x06, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x31, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x0C, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x32, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
     0x19, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
     0x30, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
     0x06, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
-    0x0A, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x36, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x25, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
-    0x30, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x1F, 0x00, 0x00, 0x00,
-    0x38, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x21, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x13, 0x00, 0x00, 0x00, 0x3A, 0x00, 0x00, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x00,
-    0x3A, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00,
-    0x3C, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x19, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x00, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x1C, 0x00, 0x00, 0x00,
-    0x3F, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x05, 0x00, 0x25, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00,
+    0x24, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x1F, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x21, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
+    0xDA, 0x00, 0x01, 0x00, 0x41, 0x00, 0x06, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x3A, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00,
+    0x0C, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x00, 0x00, 0x3A, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x39, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00,
     0x41, 0x00, 0x05, 0x00, 0x25, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
     0x24, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
     0x1F, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
     0x3E, 0x00, 0x03, 0x00, 0x21, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00,
-    0xDA, 0x00, 0x01, 0x00, 0x41, 0x00, 0x06, 0x00, 0x13, 0x00, 0x00, 0x00,
-    0x42, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0x0C, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x43, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x16, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
-    0x0C, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x44, 0x00, 0x00, 0x00,
-    0x43, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x19, 0x00, 0x00, 0x00,
-    0x45, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x46, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x1C, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x47, 0x00, 0x00, 0x00,
-    0x46, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x25, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x21, 0x00, 0x00, 0x00,
-    0x49, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00, 0xDB, 0x00, 0x01, 0x00,
+    0xDA, 0x00, 0x01, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x1D, 0x00, 0x00, 0x00,
+    0x1B, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x21, 0x00, 0x00, 0x00,
+    0x27, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00, 0xDB, 0x00, 0x01, 0x00,
     0xFD, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00,
 };
diff --git a/src/xenia/gpu/vulkan/shaders/bin/line_quad_list_geom.txt b/src/xenia/gpu/vulkan/shaders/bin/line_quad_list_geom.txt
index 67bef9604..17e49e49a 100644
--- a/src/xenia/gpu/vulkan/shaders/bin/line_quad_list_geom.txt
+++ b/src/xenia/gpu/vulkan/shaders/bin/line_quad_list_geom.txt
@@ -95,51 +95,37 @@
                OpEmitVertex
          %40 = OpAccessChain %_ptr_Input_v4float %gl_in %int_1 %int_0
          %41 = OpLoad %v4float %40
-         %42 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %42 %41
+               OpStore %23 %41
          %43 = OpAccessChain %_ptr_Input_float %gl_in %int_1 %int_1
          %44 = OpLoad %float %43
-         %45 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %45 %44
+               OpStore %29 %44
          %46 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_1
          %47 = OpLoad %_arr_v4float_uint_16 %46
                OpStore %out_interpolators %47
                OpEmitVertex
          %49 = OpAccessChain %_ptr_Input_v4float %gl_in %int_2 %int_0
          %50 = OpLoad %v4float %49
-         %51 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %51 %50
+               OpStore %23 %50
          %52 = OpAccessChain %_ptr_Input_float %gl_in %int_2 %int_1
          %53 = OpLoad %float %52
-         %54 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %54 %53
+               OpStore %29 %53
          %55 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_2
          %56 = OpLoad %_arr_v4float_uint_16 %55
                OpStore %out_interpolators %56
                OpEmitVertex
          %58 = OpAccessChain %_ptr_Input_v4float %gl_in %int_3 %int_0
          %59 = OpLoad %v4float %58
-         %60 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %60 %59
+               OpStore %23 %59
          %61 = OpAccessChain %_ptr_Input_float %gl_in %int_3 %int_1
          %62 = OpLoad %float %61
-         %63 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %63 %62
+               OpStore %29 %62
          %64 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_3
          %65 = OpLoad %_arr_v4float_uint_16 %64
                OpStore %out_interpolators %65
                OpEmitVertex
-         %66 = OpAccessChain %_ptr_Input_v4float %gl_in %int_0 %int_0
-         %67 = OpLoad %v4float %66
-         %68 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %68 %67
-         %69 = OpAccessChain %_ptr_Input_float %gl_in %int_0 %int_1
-         %70 = OpLoad %float %69
-         %71 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %71 %70
-         %72 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_0
-         %73 = OpLoad %_arr_v4float_uint_16 %72
-               OpStore %out_interpolators %73
+               OpStore %23 %21
+               OpStore %29 %27
+               OpStore %out_interpolators %39
                OpEmitVertex
                OpEndPrimitive
                OpReturn
diff --git a/src/xenia/gpu/vulkan/shaders/bin/point_list_geom.h b/src/xenia/gpu/vulkan/shaders/bin/point_list_geom.h
index b4e31a57d..4d294d48c 100644
--- a/src/xenia/gpu/vulkan/shaders/bin/point_list_geom.h
+++ b/src/xenia/gpu/vulkan/shaders/bin/point_list_geom.h
@@ -2,7 +2,7 @@
 // source: point_list.geom
 const uint8_t point_list_geom[] = {
     0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x06, 0x00, 0x08, 0x00,
-    0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
+    0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
     0x02, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00,
     0x47, 0x4C, 0x53, 0x4C, 0x2E, 0x73, 0x74, 0x64, 0x2E, 0x34, 0x35, 0x30,
     0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -26,107 +26,100 @@ const uint8_t point_list_geom[] = {
     0x68, 0x61, 0x64, 0x69, 0x6E, 0x67, 0x5F, 0x6C, 0x61, 0x6E, 0x67, 0x75,
     0x61, 0x67, 0x65, 0x5F, 0x34, 0x32, 0x30, 0x70, 0x61, 0x63, 0x6B, 0x00,
     0x05, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00, 0x6D, 0x61, 0x69, 0x6E,
-    0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x70, 0x6F, 0x73, 0x00, 0x05, 0x00, 0x06, 0x00, 0x0A, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x0A, 0x00, 0x00, 0x00,
     0x67, 0x6C, 0x5F, 0x50, 0x65, 0x72, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78,
     0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00, 0x0A, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50, 0x6F, 0x73, 0x69, 0x74,
     0x69, 0x6F, 0x6E, 0x00, 0x05, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00,
     0x67, 0x6C, 0x5F, 0x69, 0x6E, 0x00, 0x00, 0x00, 0x05, 0x00, 0x07, 0x00,
-    0x17, 0x00, 0x00, 0x00, 0x77, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x5F, 0x73,
-    0x63, 0x61, 0x6C, 0x65, 0x64, 0x5F, 0x70, 0x73, 0x69, 0x7A, 0x65, 0x00,
-    0x05, 0x00, 0x07, 0x00, 0x18, 0x00, 0x00, 0x00, 0x70, 0x75, 0x73, 0x68,
-    0x5F, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x73, 0x5F, 0x74, 0x79, 0x70, 0x65,
-    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x07, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x77, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x5F, 0x73,
-    0x63, 0x61, 0x6C, 0x65, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x05, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x76, 0x74, 0x78, 0x5F,
-    0x66, 0x6D, 0x74, 0x00, 0x06, 0x00, 0x06, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x5F, 0x73, 0x69,
-    0x7A, 0x65, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x61, 0x6C, 0x70, 0x68, 0x61, 0x5F, 0x74, 0x65,
-    0x73, 0x74, 0x00, 0x00, 0x06, 0x00, 0x07, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x04, 0x00, 0x00, 0x00, 0x70, 0x73, 0x5F, 0x70, 0x61, 0x72, 0x61, 0x6D,
-    0x5F, 0x67, 0x65, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00,
-    0x1A, 0x00, 0x00, 0x00, 0x70, 0x75, 0x73, 0x68, 0x5F, 0x63, 0x6F, 0x6E,
-    0x73, 0x74, 0x61, 0x6E, 0x74, 0x73, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00,
-    0x22, 0x00, 0x00, 0x00, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x5F, 0x73, 0x69,
-    0x7A, 0x65, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00, 0x34, 0x00, 0x00, 0x00,
-    0x69, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x3D, 0x00, 0x00, 0x00,
-    0x67, 0x6C, 0x5F, 0x50, 0x65, 0x72, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78,
-    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00, 0x3D, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50, 0x6F, 0x73, 0x69, 0x74,
-    0x69, 0x6F, 0x6E, 0x00, 0x05, 0x00, 0x03, 0x00, 0x3F, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x4D, 0x00, 0x00, 0x00,
-    0x69, 0x6E, 0x64, 0x65, 0x78, 0x61, 0x62, 0x6C, 0x65, 0x00, 0x00, 0x00,
-    0x05, 0x00, 0x07, 0x00, 0x5F, 0x00, 0x00, 0x00, 0x6F, 0x75, 0x74, 0x5F,
-    0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x6F, 0x6C, 0x61, 0x74, 0x6F, 0x72,
-    0x73, 0x00, 0x00, 0x00, 0x05, 0x00, 0x07, 0x00, 0x62, 0x00, 0x00, 0x00,
-    0x69, 0x6E, 0x5F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x6F, 0x6C, 0x61,
-    0x74, 0x6F, 0x72, 0x73, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00,
-    0x67, 0x00, 0x00, 0x00, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x5F, 0x63, 0x6F,
-    0x6F, 0x72, 0x64, 0x00, 0x05, 0x00, 0x05, 0x00, 0x69, 0x00, 0x00, 0x00,
-    0x69, 0x6E, 0x64, 0x65, 0x78, 0x61, 0x62, 0x6C, 0x65, 0x00, 0x00, 0x00,
-    0x05, 0x00, 0x08, 0x00, 0x73, 0x00, 0x00, 0x00, 0x69, 0x6E, 0x5F, 0x70,
-    0x6F, 0x69, 0x6E, 0x74, 0x5F, 0x63, 0x6F, 0x6F, 0x72, 0x64, 0x5F, 0x75,
-    0x6E, 0x75, 0x73, 0x65, 0x64, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00, 0x0A, 0x00, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x23, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-    0x23, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x22, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x05, 0x00, 0x3D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00,
-    0x3D, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x5F, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x47, 0x00, 0x04, 0x00, 0x62, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x67, 0x00, 0x00, 0x00,
-    0x1E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x73, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x03, 0x00, 0x0A, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x0B, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
-    0x0B, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x04, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
-    0x0C, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x15, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x17, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x16, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x07, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x19, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x19, 0x00, 0x00, 0x00,
-    0x1A, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-    0x21, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x3B, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x23, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x14, 0x00, 0x02, 0x00, 0x27, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-    0x33, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x70, 0x75, 0x73, 0x68, 0x5F, 0x63, 0x6F, 0x6E,
+    0x73, 0x74, 0x73, 0x5F, 0x74, 0x79, 0x70, 0x65, 0x00, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x07, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x77, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x5F, 0x73, 0x63, 0x61, 0x6C, 0x65,
+    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x76, 0x74, 0x78, 0x5F, 0x66, 0x6D, 0x74, 0x00,
+    0x06, 0x00, 0x06, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x70, 0x6F, 0x69, 0x6E, 0x74, 0x5F, 0x73, 0x69, 0x7A, 0x65, 0x00, 0x00,
+    0x06, 0x00, 0x06, 0x00, 0x18, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x61, 0x6C, 0x70, 0x68, 0x61, 0x5F, 0x74, 0x65, 0x73, 0x74, 0x00, 0x00,
+    0x06, 0x00, 0x07, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x70, 0x73, 0x5F, 0x70, 0x61, 0x72, 0x61, 0x6D, 0x5F, 0x67, 0x65, 0x6E,
+    0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x1A, 0x00, 0x00, 0x00,
+    0x70, 0x75, 0x73, 0x68, 0x5F, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E,
+    0x74, 0x73, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x70, 0x6F, 0x69, 0x6E, 0x74, 0x5F, 0x73, 0x69, 0x7A, 0x65, 0x00, 0x00,
+    0x05, 0x00, 0x06, 0x00, 0x3D, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
+    0x65, 0x72, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x06, 0x00, 0x3D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x67, 0x6C, 0x5F, 0x50, 0x6F, 0x73, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x00,
+    0x05, 0x00, 0x03, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x05, 0x00, 0x4D, 0x00, 0x00, 0x00, 0x69, 0x6E, 0x64, 0x65,
+    0x78, 0x61, 0x62, 0x6C, 0x65, 0x00, 0x00, 0x00, 0x05, 0x00, 0x07, 0x00,
+    0x5F, 0x00, 0x00, 0x00, 0x6F, 0x75, 0x74, 0x5F, 0x69, 0x6E, 0x74, 0x65,
+    0x72, 0x70, 0x6F, 0x6C, 0x61, 0x74, 0x6F, 0x72, 0x73, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x07, 0x00, 0x62, 0x00, 0x00, 0x00, 0x69, 0x6E, 0x5F, 0x69,
+    0x6E, 0x74, 0x65, 0x72, 0x70, 0x6F, 0x6C, 0x61, 0x74, 0x6F, 0x72, 0x73,
+    0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x67, 0x00, 0x00, 0x00,
+    0x70, 0x6F, 0x69, 0x6E, 0x74, 0x5F, 0x63, 0x6F, 0x6F, 0x72, 0x64, 0x00,
+    0x05, 0x00, 0x05, 0x00, 0x69, 0x00, 0x00, 0x00, 0x69, 0x6E, 0x64, 0x65,
+    0x78, 0x61, 0x62, 0x6C, 0x65, 0x00, 0x00, 0x00, 0x05, 0x00, 0x08, 0x00,
+    0x73, 0x00, 0x00, 0x00, 0x69, 0x6E, 0x5F, 0x70, 0x6F, 0x69, 0x6E, 0x74,
+    0x5F, 0x63, 0x6F, 0x6F, 0x72, 0x64, 0x5F, 0x75, 0x6E, 0x75, 0x73, 0x65,
+    0x64, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x0A, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x03, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x48, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x48, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x23, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+    0x40, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x1E, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
+    0x3D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00, 0x3D, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x5F, 0x00, 0x00, 0x00,
+    0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+    0x62, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x04, 0x00, 0x67, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x73, 0x00, 0x00, 0x00,
+    0x1E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x03, 0x00,
+    0x0A, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00,
+    0x0B, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x04, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x0D, 0x00, 0x00, 0x00,
+    0x0A, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x0E, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x04, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x1E, 0x00, 0x07, 0x00, 0x18, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x0B, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x09, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00,
+    0x09, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x23, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x02, 0x00, 0x27, 0x00, 0x00, 0x00,
     0x2B, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x00,
     0x04, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x03, 0x00, 0x3D, 0x00, 0x00, 0x00,
     0x07, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x3E, 0x00, 0x00, 0x00,
@@ -172,23 +165,17 @@ const uint8_t point_list_geom[] = {
     0x01, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00,
     0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
     0xF8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x3B, 0x00, 0x04, 0x00, 0x16, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x33, 0x00, 0x00, 0x00,
-    0x34, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
     0x4C, 0x00, 0x00, 0x00, 0x4D, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
     0x3B, 0x00, 0x04, 0x00, 0x4C, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00,
     0x07, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00,
     0x13, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
     0x11, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x14, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
     0x1C, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00,
     0x1B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
     0x1E, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00,
     0x15, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
     0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x17, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00,
     0x41, 0x00, 0x05, 0x00, 0x23, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
     0x22, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
     0x06, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
@@ -196,57 +183,44 @@ const uint8_t point_list_geom[] = {
     0x25, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0xF7, 0x00, 0x03, 0x00,
     0x2A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x04, 0x00,
     0x28, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
-    0xF8, 0x00, 0x02, 0x00, 0x29, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x23, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
-    0x11, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x2C, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x50, 0x00, 0x05, 0x00,
-    0x15, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00,
-    0x2C, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x17, 0x00, 0x00, 0x00,
-    0x2D, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00, 0x2A, 0x00, 0x00, 0x00,
-    0xF8, 0x00, 0x02, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x1C, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00,
-    0x11, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x2F, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00,
-    0x15, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00,
-    0x2F, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
-    0x17, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00,
-    0x32, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x17, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x34, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0xF8, 0x00, 0x02, 0x00, 0x29, 0x00, 0x00, 0x00, 0x50, 0x00, 0x05, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x25, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0xF8, 0x00, 0x02, 0x00, 0x2A, 0x00, 0x00, 0x00, 0xF5, 0x00, 0x07, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x05, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00,
+    0x1A, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00,
+    0x4F, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x2F, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x32, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
     0xF9, 0x00, 0x02, 0x00, 0x35, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
-    0x35, 0x00, 0x00, 0x00, 0xF6, 0x00, 0x04, 0x00, 0x37, 0x00, 0x00, 0x00,
-    0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00,
-    0x39, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x39, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3A, 0x00, 0x00, 0x00,
-    0x34, 0x00, 0x00, 0x00, 0xB1, 0x00, 0x05, 0x00, 0x27, 0x00, 0x00, 0x00,
-    0x3C, 0x00, 0x00, 0x00, 0x3A, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x00,
-    0xFA, 0x00, 0x04, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
-    0x37, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x36, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
+    0x35, 0x00, 0x00, 0x00, 0xF5, 0x00, 0x07, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x75, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0x70, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0xB1, 0x00, 0x05, 0x00,
+    0x27, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x00, 0x00, 0xF6, 0x00, 0x04, 0x00, 0x37, 0x00, 0x00, 0x00,
+    0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x04, 0x00,
+    0x3C, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00,
+    0xF8, 0x00, 0x02, 0x00, 0x36, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
     0x3E, 0x00, 0x03, 0x00, 0x4D, 0x00, 0x00, 0x00, 0x4A, 0x00, 0x00, 0x00,
     0x41, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0x4E, 0x00, 0x00, 0x00,
-    0x4D, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x4D, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
     0x15, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x00, 0x00, 0x4E, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
-    0x17, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00,
-    0x51, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
-    0x81, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x4F, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00,
-    0x53, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x85, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00,
+    0x4F, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00,
+    0x51, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00,
     0x55, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00,
     0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x58, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x58, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
     0x50, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00,
     0x55, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00,
     0x58, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x5A, 0x00, 0x00, 0x00,
@@ -256,21 +230,16 @@ const uint8_t point_list_geom[] = {
     0x62, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
     0x5D, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
     0x3E, 0x00, 0x03, 0x00, 0x5F, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
-    0x34, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x69, 0x00, 0x00, 0x00,
-    0x4A, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00,
-    0x6A, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00, 0x6B, 0x00, 0x00, 0x00,
-    0x6A, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00,
-    0x6D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
-    0x6B, 0x00, 0x00, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x67, 0x00, 0x00, 0x00, 0x6D, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00,
-    0xF9, 0x00, 0x02, 0x00, 0x38, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
-    0x38, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x6E, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x6E, 0x00, 0x00, 0x00,
-    0x6F, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x34, 0x00, 0x00, 0x00,
-    0x70, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00, 0x35, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x69, 0x00, 0x00, 0x00, 0x4A, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0x6A, 0x00, 0x00, 0x00,
+    0x69, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x6B, 0x00, 0x00, 0x00, 0x6A, 0x00, 0x00, 0x00,
+    0x0C, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0x6D, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x6B, 0x00, 0x00, 0x00,
+    0x6C, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x67, 0x00, 0x00, 0x00,
+    0x6D, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00, 0x80, 0x00, 0x05, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00,
+    0x6F, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00, 0x35, 0x00, 0x00, 0x00,
     0xF8, 0x00, 0x02, 0x00, 0x37, 0x00, 0x00, 0x00, 0xDB, 0x00, 0x01, 0x00,
     0xFD, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00,
 };
diff --git a/src/xenia/gpu/vulkan/shaders/bin/point_list_geom.txt b/src/xenia/gpu/vulkan/shaders/bin/point_list_geom.txt
index 3a26e517c..0eec50c66 100644
--- a/src/xenia/gpu/vulkan/shaders/bin/point_list_geom.txt
+++ b/src/xenia/gpu/vulkan/shaders/bin/point_list_geom.txt
@@ -1,7 +1,7 @@
 ; SPIR-V
 ; Version: 1.0
 ; Generator: Khronos Glslang Reference Front End; 6
-; Bound: 116
+; Bound: 118
 ; Schema: 0
                OpCapability Geometry
           %1 = OpExtInstImport "GLSL.std.450"
@@ -16,11 +16,9 @@
                OpSourceExtension "GL_ARB_separate_shader_objects"
                OpSourceExtension "GL_ARB_shading_language_420pack"
                OpName %main "main"
-               OpName %pos "pos"
                OpName %gl_PerVertex "gl_PerVertex"
                OpMemberName %gl_PerVertex 0 "gl_Position"
                OpName %gl_in "gl_in"
-               OpName %window_scaled_psize "window_scaled_psize"
                OpName %push_consts_type "push_consts_type"
                OpMemberName %push_consts_type 0 "window_scale"
                OpMemberName %push_consts_type 1 "vtx_fmt"
@@ -29,7 +27,6 @@
                OpMemberName %push_consts_type 4 "ps_param_gen"
                OpName %push_constants "push_constants"
                OpName %point_size "point_size"
-               OpName %i "i"
                OpName %gl_PerVertex_0 "gl_PerVertex"
                OpMemberName %gl_PerVertex_0 0 "gl_Position"
                OpName %_ ""
@@ -58,7 +55,6 @@
           %3 = OpTypeFunction %void
       %float = OpTypeFloat 32
     %v4float = OpTypeVector %float 4
-%_ptr_Function_v4float = OpTypePointer Function %v4float
 %gl_PerVertex = OpTypeStruct %v4float
        %uint = OpTypeInt 32 0
      %uint_1 = OpConstant %uint 1
@@ -81,7 +77,6 @@
 %_ptr_Input_float = OpTypePointer Input %float
     %float_0 = OpConstant %float 0
        %bool = OpTypeBool
-%_ptr_Function_int = OpTypePointer Function %int
       %int_4 = OpConstant %int 4
 %gl_PerVertex_0 = OpTypeStruct %v4float
 %_ptr_Output_gl_PerVertex_0 = OpTypePointer Output %gl_PerVertex_0
@@ -114,79 +109,57 @@
 %in_point_coord_unused = OpVariable %_ptr_Input__arr_v2float_uint_1 Input
        %main = OpFunction %void None %3
           %5 = OpLabel
-        %pos = OpVariable %_ptr_Function_v4float Function
-%window_scaled_psize = OpVariable %_ptr_Function_v2float Function
-          %i = OpVariable %_ptr_Function_int Function
   %indexable = OpVariable %_ptr_Function__arr_v2float_uint_4 Function
 %indexable_0 = OpVariable %_ptr_Function__arr_v2float_uint_4 Function
          %19 = OpAccessChain %_ptr_Input_v4float %gl_in %int_0 %int_0
          %20 = OpLoad %v4float %19
-               OpStore %pos %20
          %29 = OpAccessChain %_ptr_PushConstant_v4float %push_constants %int_2
          %30 = OpLoad %v4float %29
          %31 = OpVectorShuffle %v2float %30 %30 0 1
-               OpStore %window_scaled_psize %31
          %36 = OpAccessChain %_ptr_Input_float %point_size %int_0
          %37 = OpLoad %float %36
          %40 = OpFOrdGreaterThan %bool %37 %float_0
                OpSelectionMerge %42 None
                OpBranchConditional %40 %41 %42
          %41 = OpLabel
-         %43 = OpAccessChain %_ptr_Input_float %point_size %int_0
-         %44 = OpLoad %float %43
-         %45 = OpCompositeConstruct %v2float %44 %44
-               OpStore %window_scaled_psize %45
+         %45 = OpCompositeConstruct %v2float %37 %37
                OpBranch %42
          %42 = OpLabel
+        %116 = OpPhi %v2float %31 %5 %45 %41
          %46 = OpAccessChain %_ptr_PushConstant_v4float %push_constants %int_0
          %47 = OpLoad %v4float %46
          %48 = OpVectorShuffle %v2float %47 %47 2 3
-         %49 = OpLoad %v2float %window_scaled_psize
-         %50 = OpFDiv %v2float %49 %48
-               OpStore %window_scaled_psize %50
-               OpStore %i %int_0
+         %50 = OpFDiv %v2float %116 %48
                OpBranch %53
          %53 = OpLabel
-               OpLoopMerge %55 %56 None
-               OpBranch %57
-         %57 = OpLabel
-         %58 = OpLoad %int %i
-         %60 = OpSLessThan %bool %58 %int_4
+        %117 = OpPhi %int %int_0 %42 %112 %54
+         %60 = OpSLessThan %bool %117 %int_4
+               OpLoopMerge %55 %54 None
                OpBranchConditional %60 %54 %55
          %54 = OpLabel
-         %64 = OpLoad %v4float %pos
-         %65 = OpVectorShuffle %v2float %64 %64 0 1
-         %75 = OpLoad %int %i
+         %65 = OpVectorShuffle %v2float %20 %20 0 1
                OpStore %indexable %74
-         %78 = OpAccessChain %_ptr_Function_v2float %indexable %75
+         %78 = OpAccessChain %_ptr_Function_v2float %indexable %117
          %79 = OpLoad %v2float %78
-         %80 = OpLoad %v2float %window_scaled_psize
-         %81 = OpFMul %v2float %79 %80
+         %81 = OpFMul %v2float %79 %50
          %82 = OpFAdd %v2float %65 %81
-         %83 = OpLoad %v4float %pos
-         %84 = OpVectorShuffle %v2float %83 %83 2 3
          %85 = OpCompositeExtract %float %82 0
          %86 = OpCompositeExtract %float %82 1
-         %87 = OpCompositeExtract %float %84 0
-         %88 = OpCompositeExtract %float %84 1
+         %87 = OpCompositeExtract %float %20 2
+         %88 = OpCompositeExtract %float %20 3
          %89 = OpCompositeConstruct %v4float %85 %86 %87 %88
          %91 = OpAccessChain %_ptr_Output_v4float %_ %int_0
                OpStore %91 %89
         %100 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_0
         %101 = OpLoad %_arr_v4float_uint_16 %100
                OpStore %out_interpolators %101
-        %104 = OpLoad %int %i
                OpStore %indexable_0 %74
-        %106 = OpAccessChain %_ptr_Function_v2float %indexable_0 %104
+        %106 = OpAccessChain %_ptr_Function_v2float %indexable_0 %117
         %107 = OpLoad %v2float %106
         %109 = OpExtInst %v2float %1 FMax %107 %108
                OpStore %point_coord %109
                OpEmitVertex
-               OpBranch %56
-         %56 = OpLabel
-        %110 = OpLoad %int %i
-        %112 = OpIAdd %int %110 %int_1
-               OpStore %i %112
+        %112 = OpIAdd %int %117 %int_1
                OpBranch %53
          %55 = OpLabel
                OpEndPrimitive
diff --git a/src/xenia/gpu/vulkan/shaders/bin/quad_list_geom.h b/src/xenia/gpu/vulkan/shaders/bin/quad_list_geom.h
index fc8540095..fd5741897 100644
--- a/src/xenia/gpu/vulkan/shaders/bin/quad_list_geom.h
+++ b/src/xenia/gpu/vulkan/shaders/bin/quad_list_geom.h
@@ -2,7 +2,7 @@
 // source: quad_list.geom
 const uint8_t quad_list_geom[] = {
     0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x06, 0x00, 0x08, 0x00,
-    0x4B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
+    0x4C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
     0x02, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00, 0x18, 0x00, 0x00, 0x00,
     0x0B, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00, 0x47, 0x4C, 0x53, 0x4C,
     0x2E, 0x73, 0x74, 0x64, 0x2E, 0x34, 0x35, 0x30, 0x00, 0x00, 0x00, 0x00,
@@ -27,161 +27,145 @@ const uint8_t quad_list_geom[] = {
     0x6E, 0x67, 0x5F, 0x6C, 0x61, 0x6E, 0x67, 0x75, 0x61, 0x67, 0x65, 0x5F,
     0x34, 0x32, 0x30, 0x70, 0x61, 0x63, 0x6B, 0x00, 0x05, 0x00, 0x04, 0x00,
     0x04, 0x00, 0x00, 0x00, 0x6D, 0x61, 0x69, 0x6E, 0x00, 0x00, 0x00, 0x00,
-    0x05, 0x00, 0x03, 0x00, 0x08, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00,
-    0x05, 0x00, 0x05, 0x00, 0x13, 0x00, 0x00, 0x00, 0x69, 0x6E, 0x70, 0x75,
-    0x74, 0x5F, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x00, 0x05, 0x00, 0x05, 0x00,
-    0x1D, 0x00, 0x00, 0x00, 0x69, 0x6E, 0x64, 0x65, 0x78, 0x61, 0x62, 0x6C,
-    0x65, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x22, 0x00, 0x00, 0x00,
-    0x67, 0x6C, 0x5F, 0x50, 0x65, 0x72, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78,
-    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00, 0x22, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50, 0x6F, 0x73, 0x69, 0x74,
-    0x69, 0x6F, 0x6E, 0x00, 0x06, 0x00, 0x07, 0x00, 0x22, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50, 0x6F, 0x69, 0x6E, 0x74,
-    0x53, 0x69, 0x7A, 0x65, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00,
-    0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00,
-    0x25, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50, 0x65, 0x72, 0x56, 0x65,
+    0x05, 0x00, 0x05, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x69, 0x6E, 0x64, 0x65,
+    0x78, 0x61, 0x62, 0x6C, 0x65, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50, 0x65, 0x72, 0x56, 0x65,
     0x72, 0x74, 0x65, 0x78, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00,
-    0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
+    0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
     0x6F, 0x73, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x00, 0x06, 0x00, 0x07, 0x00,
-    0x25, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
+    0x22, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
     0x6F, 0x69, 0x6E, 0x74, 0x53, 0x69, 0x7A, 0x65, 0x00, 0x00, 0x00, 0x00,
-    0x05, 0x00, 0x04, 0x00, 0x28, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x69,
-    0x6E, 0x00, 0x00, 0x00, 0x05, 0x00, 0x07, 0x00, 0x38, 0x00, 0x00, 0x00,
-    0x6F, 0x75, 0x74, 0x5F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x6F, 0x6C,
-    0x61, 0x74, 0x6F, 0x72, 0x73, 0x00, 0x00, 0x00, 0x05, 0x00, 0x07, 0x00,
-    0x3B, 0x00, 0x00, 0x00, 0x69, 0x6E, 0x5F, 0x69, 0x6E, 0x74, 0x65, 0x72,
-    0x70, 0x6F, 0x6C, 0x61, 0x74, 0x6F, 0x72, 0x73, 0x00, 0x00, 0x00, 0x00,
-    0x05, 0x00, 0x08, 0x00, 0x45, 0x00, 0x00, 0x00, 0x5F, 0x69, 0x6E, 0x5F,
-    0x70, 0x6F, 0x69, 0x6E, 0x74, 0x5F, 0x63, 0x6F, 0x6F, 0x72, 0x64, 0x5F,
-    0x75, 0x6E, 0x75, 0x73, 0x65, 0x64, 0x00, 0x00, 0x05, 0x00, 0x08, 0x00,
-    0x48, 0x00, 0x00, 0x00, 0x5F, 0x69, 0x6E, 0x5F, 0x70, 0x6F, 0x69, 0x6E,
-    0x74, 0x5F, 0x73, 0x69, 0x7A, 0x65, 0x5F, 0x75, 0x6E, 0x75, 0x73, 0x65,
-    0x64, 0x00, 0x00, 0x00, 0x05, 0x00, 0x08, 0x00, 0x4A, 0x00, 0x00, 0x00,
-    0x5F, 0x6F, 0x75, 0x74, 0x5F, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x5F, 0x63,
-    0x6F, 0x6F, 0x72, 0x64, 0x5F, 0x75, 0x6E, 0x75, 0x73, 0x65, 0x64, 0x00,
-    0x48, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
-    0x22, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00, 0x22, 0x00, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x03, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x06, 0x00, 0x25, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
+    0x65, 0x72, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x06, 0x00, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x67, 0x6C, 0x5F, 0x50, 0x6F, 0x73, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x00,
+    0x06, 0x00, 0x07, 0x00, 0x25, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x67, 0x6C, 0x5F, 0x50, 0x6F, 0x69, 0x6E, 0x74, 0x53, 0x69, 0x7A, 0x65,
+    0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00, 0x28, 0x00, 0x00, 0x00,
+    0x67, 0x6C, 0x5F, 0x69, 0x6E, 0x00, 0x00, 0x00, 0x05, 0x00, 0x07, 0x00,
+    0x38, 0x00, 0x00, 0x00, 0x6F, 0x75, 0x74, 0x5F, 0x69, 0x6E, 0x74, 0x65,
+    0x72, 0x70, 0x6F, 0x6C, 0x61, 0x74, 0x6F, 0x72, 0x73, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x07, 0x00, 0x3B, 0x00, 0x00, 0x00, 0x69, 0x6E, 0x5F, 0x69,
+    0x6E, 0x74, 0x65, 0x72, 0x70, 0x6F, 0x6C, 0x61, 0x74, 0x6F, 0x72, 0x73,
+    0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x08, 0x00, 0x45, 0x00, 0x00, 0x00,
+    0x5F, 0x69, 0x6E, 0x5F, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x5F, 0x63, 0x6F,
+    0x6F, 0x72, 0x64, 0x5F, 0x75, 0x6E, 0x75, 0x73, 0x65, 0x64, 0x00, 0x00,
+    0x05, 0x00, 0x08, 0x00, 0x48, 0x00, 0x00, 0x00, 0x5F, 0x69, 0x6E, 0x5F,
+    0x70, 0x6F, 0x69, 0x6E, 0x74, 0x5F, 0x73, 0x69, 0x7A, 0x65, 0x5F, 0x75,
+    0x6E, 0x75, 0x73, 0x65, 0x64, 0x00, 0x00, 0x00, 0x05, 0x00, 0x08, 0x00,
+    0x4A, 0x00, 0x00, 0x00, 0x5F, 0x6F, 0x75, 0x74, 0x5F, 0x70, 0x6F, 0x69,
+    0x6E, 0x74, 0x5F, 0x63, 0x6F, 0x6F, 0x72, 0x64, 0x5F, 0x75, 0x6E, 0x75,
+    0x73, 0x65, 0x64, 0x00, 0x48, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x05, 0x00, 0x25, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x48, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
     0x0B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00,
-    0x25, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x38, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x47, 0x00, 0x04, 0x00, 0x3B, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x45, 0x00, 0x00, 0x00,
-    0x1E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x48, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
-    0x47, 0x00, 0x04, 0x00, 0x4A, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x15, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x04, 0x00, 0x00, 0x00, 0x14, 0x00, 0x02, 0x00, 0x11, 0x00, 0x00, 0x00,
-    0x15, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00,
-    0x15, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00,
-    0x16, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x2C, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x19, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
-    0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-    0x1E, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x23, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x23, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x1E, 0x00, 0x04, 0x00, 0x25, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x26, 0x00, 0x00, 0x00,
-    0x25, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-    0x27, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
-    0x3B, 0x00, 0x04, 0x00, 0x27, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x2A, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-    0x2D, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x33, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
-    0x14, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x04, 0x00, 0x36, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
-    0x35, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x37, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x37, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x04, 0x00, 0x39, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
-    0x15, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x3A, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x3A, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x3D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x36, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x42, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00,
-    0x43, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x43, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x44, 0x00, 0x00, 0x00,
-    0x45, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00,
-    0x46, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x47, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x46, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x47, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-    0x49, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00,
-    0x3B, 0x00, 0x04, 0x00, 0x49, 0x00, 0x00, 0x00, 0x4A, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0xF8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x3B, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00,
-    0x1D, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00,
-    0x0A, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x00, 0x00,
-    0xF6, 0x00, 0x04, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0xF8, 0x00, 0x02, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
+    0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x03, 0x00, 0x25, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x04, 0x00, 0x38, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x3B, 0x00, 0x00, 0x00,
+    0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+    0x45, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x04, 0x00, 0x48, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x4A, 0x00, 0x00, 0x00,
+    0x1E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x14, 0x00, 0x02, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x1C, 0x00, 0x04, 0x00, 0x16, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x1A, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x1C, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x23, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x04, 0x00, 0x23, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x04, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00,
+    0x26, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x04, 0x00, 0x27, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x26, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x28, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x2A, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x04, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x33, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x36, 0x00, 0x00, 0x00,
+    0x21, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x37, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x04, 0x00, 0x37, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x39, 0x00, 0x00, 0x00,
+    0x36, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x3A, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x04, 0x00, 0x3A, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x3D, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
+    0x42, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x1C, 0x00, 0x04, 0x00, 0x43, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x44, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
+    0x44, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x1C, 0x00, 0x04, 0x00, 0x46, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x47, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
+    0x47, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x04, 0x00, 0x49, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x42, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x49, 0x00, 0x00, 0x00,
+    0x4A, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x00, 0x00,
+    0xF8, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xF5, 0x00, 0x07, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
     0xB1, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
-    0x0F, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x04, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0xF8, 0x00, 0x02, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x4B, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xF6, 0x00, 0x04, 0x00,
+    0x0C, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xFA, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
+    0x0C, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x0B, 0x00, 0x00, 0x00,
     0x3E, 0x00, 0x03, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00,
     0x41, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
-    0x1D, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x1D, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
     0x06, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x13, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
-    0x13, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x2A, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00,
-    0x2C, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x2D, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x2E, 0x00, 0x00, 0x00,
-    0x2C, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x2F, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x30, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
-    0x2F, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x33, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
-    0x24, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x34, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x06, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00,
+    0x28, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x3D, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x2D, 0x00, 0x00, 0x00,
+    0x2E, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x06, 0x00, 0x30, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
+    0x28, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x3D, 0x00, 0x04, 0x00, 0x20, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
+    0x31, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x33, 0x00, 0x00, 0x00,
+    0x34, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x34, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
     0x41, 0x00, 0x05, 0x00, 0x3D, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00,
-    0x3B, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x3B, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
     0x36, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00,
     0x3E, 0x00, 0x03, 0x00, 0x38, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00,
-    0xDA, 0x00, 0x01, 0x00, 0xF9, 0x00, 0x02, 0x00, 0x0D, 0x00, 0x00, 0x00,
-    0xF8, 0x00, 0x02, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x80, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00,
-    0x40, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00,
-    0x0A, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0xDB, 0x00, 0x01, 0x00, 0xFD, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00,
+    0xDA, 0x00, 0x01, 0x00, 0x80, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0xF9, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
+    0x0C, 0x00, 0x00, 0x00, 0xDB, 0x00, 0x01, 0x00, 0xFD, 0x00, 0x01, 0x00,
+    0x38, 0x00, 0x01, 0x00,
 };
diff --git a/src/xenia/gpu/vulkan/shaders/bin/quad_list_geom.txt b/src/xenia/gpu/vulkan/shaders/bin/quad_list_geom.txt
index f7325b903..a7767342d 100644
--- a/src/xenia/gpu/vulkan/shaders/bin/quad_list_geom.txt
+++ b/src/xenia/gpu/vulkan/shaders/bin/quad_list_geom.txt
@@ -1,7 +1,7 @@
 ; SPIR-V
 ; Version: 1.0
 ; Generator: Khronos Glslang Reference Front End; 6
-; Bound: 75
+; Bound: 76
 ; Schema: 0
                OpCapability Geometry
                OpCapability GeometryPointSize
@@ -17,8 +17,6 @@
                OpSourceExtension "GL_ARB_separate_shader_objects"
                OpSourceExtension "GL_ARB_shading_language_420pack"
                OpName %main "main"
-               OpName %i "i"
-               OpName %input_index "input_index"
                OpName %indexable "indexable"
                OpName %gl_PerVertex "gl_PerVertex"
                OpMemberName %gl_PerVertex 0 "gl_Position"
@@ -91,44 +89,30 @@
 %_out_point_coord_unused = OpVariable %_ptr_Output_v2float Output
        %main = OpFunction %void None %3
           %5 = OpLabel
-          %i = OpVariable %_ptr_Function_int Function
-%input_index = OpVariable %_ptr_Function_int Function
   %indexable = OpVariable %_ptr_Function__arr_int_uint_4 Function
-               OpStore %i %int_0
                OpBranch %10
          %10 = OpLabel
-               OpLoopMerge %12 %13 None
-               OpBranch %14
-         %14 = OpLabel
-         %15 = OpLoad %int %i
-         %18 = OpSLessThan %bool %15 %int_4
+         %75 = OpPhi %int %int_0 %5 %65 %11
+         %18 = OpSLessThan %bool %75 %int_4
+               OpLoopMerge %12 %11 None
                OpBranchConditional %18 %11 %12
          %11 = OpLabel
-         %27 = OpLoad %int %i
                OpStore %indexable %26
-         %30 = OpAccessChain %_ptr_Function_int %indexable %27
+         %30 = OpAccessChain %_ptr_Function_int %indexable %75
          %31 = OpLoad %int %30
-               OpStore %input_index %31
-         %41 = OpLoad %int %input_index
-         %43 = OpAccessChain %_ptr_Input_v4float %gl_in %41 %int_0
+         %43 = OpAccessChain %_ptr_Input_v4float %gl_in %31 %int_0
          %44 = OpLoad %v4float %43
          %46 = OpAccessChain %_ptr_Output_v4float %_ %int_0
                OpStore %46 %44
-         %47 = OpLoad %int %input_index
-         %49 = OpAccessChain %_ptr_Input_float %gl_in %47 %int_1
+         %49 = OpAccessChain %_ptr_Input_float %gl_in %31 %int_1
          %50 = OpLoad %float %49
          %52 = OpAccessChain %_ptr_Output_float %_ %int_1
                OpStore %52 %50
-         %60 = OpLoad %int %input_index
-         %62 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %60
+         %62 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %31
          %63 = OpLoad %_arr_v4float_uint_16 %62
                OpStore %out_interpolators %63
                OpEmitVertex
-               OpBranch %13
-         %13 = OpLabel
-         %64 = OpLoad %int %i
-         %65 = OpIAdd %int %64 %int_1
-               OpStore %i %65
+         %65 = OpIAdd %int %75 %int_1
                OpBranch %10
          %12 = OpLabel
                OpEndPrimitive
diff --git a/src/xenia/gpu/vulkan/shaders/bin/rect_list_geom.h b/src/xenia/gpu/vulkan/shaders/bin/rect_list_geom.h
index d05f58b6b..d613de39c 100644
--- a/src/xenia/gpu/vulkan/shaders/bin/rect_list_geom.h
+++ b/src/xenia/gpu/vulkan/shaders/bin/rect_list_geom.h
@@ -2,15 +2,15 @@
 // source: rect_list.geom
 const uint8_t rect_list_geom[] = {
     0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x06, 0x00, 0x08, 0x00,
-    0xFB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
+    0x28, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
     0x02, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00, 0x18, 0x00, 0x00, 0x00,
     0x0B, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00, 0x47, 0x4C, 0x53, 0x4C,
     0x2E, 0x73, 0x74, 0x64, 0x2E, 0x34, 0x35, 0x30, 0x00, 0x00, 0x00, 0x00,
     0x0E, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
     0x0F, 0x00, 0x0C, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-    0x6D, 0x61, 0x69, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0x35, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
-    0xF5, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x00, 0x00,
+    0x6D, 0x61, 0x69, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x4C, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00, 0x00,
+    0x0C, 0x01, 0x00, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x11, 0x01, 0x00, 0x00,
     0x10, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
     0x10, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00,
@@ -24,495 +24,351 @@ const uint8_t rect_list_geom[] = {
     0x61, 0x74, 0x65, 0x5F, 0x73, 0x68, 0x61, 0x64, 0x65, 0x72, 0x5F, 0x6F,
     0x62, 0x6A, 0x65, 0x63, 0x74, 0x73, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00,
     0x04, 0x00, 0x00, 0x00, 0x6D, 0x61, 0x69, 0x6E, 0x00, 0x00, 0x00, 0x00,
-    0x05, 0x00, 0x06, 0x00, 0x09, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
+    0x05, 0x00, 0x06, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
     0x65, 0x72, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x00, 0x00, 0x00,
-    0x06, 0x00, 0x06, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x06, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x67, 0x6C, 0x5F, 0x50, 0x6F, 0x73, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x00,
-    0x06, 0x00, 0x07, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x07, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
     0x67, 0x6C, 0x5F, 0x50, 0x6F, 0x69, 0x6E, 0x74, 0x53, 0x69, 0x7A, 0x65,
-    0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00, 0x0E, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00,
     0x67, 0x6C, 0x5F, 0x69, 0x6E, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00,
-    0x33, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50, 0x65, 0x72, 0x56, 0x65,
+    0x4A, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50, 0x65, 0x72, 0x56, 0x65,
     0x72, 0x74, 0x65, 0x78, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00,
-    0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
+    0x4A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
     0x6F, 0x73, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x00, 0x06, 0x00, 0x07, 0x00,
-    0x33, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
+    0x4A, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
     0x6F, 0x69, 0x6E, 0x74, 0x53, 0x69, 0x7A, 0x65, 0x00, 0x00, 0x00, 0x00,
-    0x05, 0x00, 0x03, 0x00, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x05, 0x00, 0x07, 0x00, 0x41, 0x00, 0x00, 0x00, 0x6F, 0x75, 0x74, 0x5F,
+    0x05, 0x00, 0x03, 0x00, 0x4C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x07, 0x00, 0x58, 0x00, 0x00, 0x00, 0x6F, 0x75, 0x74, 0x5F,
     0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x6F, 0x6C, 0x61, 0x74, 0x6F, 0x72,
-    0x73, 0x00, 0x00, 0x00, 0x05, 0x00, 0x07, 0x00, 0x44, 0x00, 0x00, 0x00,
+    0x73, 0x00, 0x00, 0x00, 0x05, 0x00, 0x07, 0x00, 0x5B, 0x00, 0x00, 0x00,
     0x69, 0x6E, 0x5F, 0x69, 0x6E, 0x74, 0x65, 0x72, 0x70, 0x6F, 0x6C, 0x61,
-    0x74, 0x6F, 0x72, 0x73, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00,
-    0x81, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00,
-    0xDB, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x05, 0x00, 0x08, 0x00,
-    0xF5, 0x00, 0x00, 0x00, 0x5F, 0x69, 0x6E, 0x5F, 0x70, 0x6F, 0x69, 0x6E,
+    0x74, 0x6F, 0x72, 0x73, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x08, 0x00,
+    0x0C, 0x01, 0x00, 0x00, 0x5F, 0x69, 0x6E, 0x5F, 0x70, 0x6F, 0x69, 0x6E,
     0x74, 0x5F, 0x63, 0x6F, 0x6F, 0x72, 0x64, 0x5F, 0x75, 0x6E, 0x75, 0x73,
-    0x65, 0x64, 0x00, 0x00, 0x05, 0x00, 0x08, 0x00, 0xF8, 0x00, 0x00, 0x00,
+    0x65, 0x64, 0x00, 0x00, 0x05, 0x00, 0x08, 0x00, 0x0F, 0x01, 0x00, 0x00,
     0x5F, 0x69, 0x6E, 0x5F, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x5F, 0x73, 0x69,
     0x7A, 0x65, 0x5F, 0x75, 0x6E, 0x75, 0x73, 0x65, 0x64, 0x00, 0x00, 0x00,
-    0x05, 0x00, 0x08, 0x00, 0xFA, 0x00, 0x00, 0x00, 0x5F, 0x6F, 0x75, 0x74,
+    0x05, 0x00, 0x08, 0x00, 0x11, 0x01, 0x00, 0x00, 0x5F, 0x6F, 0x75, 0x74,
     0x5F, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x5F, 0x63, 0x6F, 0x6F, 0x72, 0x64,
     0x5F, 0x75, 0x6E, 0x75, 0x73, 0x65, 0x64, 0x00, 0x48, 0x00, 0x05, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x1D, 0x00, 0x00, 0x00,
     0x01, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x47, 0x00, 0x03, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x05, 0x00, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x03, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x48, 0x00, 0x05, 0x00, 0x4A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
-    0x33, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00, 0x33, 0x00, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x41, 0x00, 0x00, 0x00,
+    0x4A, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00, 0x4A, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x58, 0x00, 0x00, 0x00,
     0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x44, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x47, 0x00, 0x04, 0x00, 0xF5, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0xF8, 0x00, 0x00, 0x00,
+    0x5B, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x04, 0x00, 0x0C, 0x01, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0F, 0x01, 0x00, 0x00,
     0x1E, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0xFA, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x11, 0x01, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
     0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x14, 0x00, 0x02, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x04, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x15, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x00, 0x00,
-    0x0B, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00,
-    0x0C, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x0C, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x0D, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00,
-    0x0F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x00, 0x00,
-    0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x1E, 0x00, 0x04, 0x00, 0x33, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x34, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x34, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x38, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x3C, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
-    0x0A, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x04, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x40, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x04, 0x00, 0x42, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00,
-    0x0B, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x43, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x43, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x45, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x3F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x80, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
-    0x0F, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x04, 0x00, 0xF3, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
-    0x0B, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0xF4, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0xF3, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0xF4, 0x00, 0x00, 0x00, 0xF5, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x04, 0x00, 0xF6, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x0B, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0xF7, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0xF6, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0xF7, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0xF9, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x11, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0xF9, 0x00, 0x00, 0x00,
-    0xFA, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
-    0x3B, 0x00, 0x04, 0x00, 0x80, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x80, 0x00, 0x00, 0x00,
-    0xDB, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
-    0x4F, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
-    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x41, 0x00, 0x07, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x19, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x07, 0x00, 0x18, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x1E, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x50, 0x00, 0x05, 0x00,
-    0x11, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00,
-    0x1E, 0x00, 0x00, 0x00, 0xB4, 0x00, 0x05, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x21, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00,
-    0x9B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
-    0x21, 0x00, 0x00, 0x00, 0xA8, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x23, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0xF7, 0x00, 0x03, 0x00,
-    0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x04, 0x00,
-    0x23, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
-    0xF8, 0x00, 0x02, 0x00, 0x24, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
-    0x4F, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
-    0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x41, 0x00, 0x07, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x29, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x07, 0x00, 0x18, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x2C, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x50, 0x00, 0x05, 0x00,
-    0x11, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
-    0x2C, 0x00, 0x00, 0x00, 0xB4, 0x00, 0x05, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x2E, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00,
-    0x9B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00,
-    0x2E, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00, 0x25, 0x00, 0x00, 0x00,
-    0xF8, 0x00, 0x02, 0x00, 0x25, 0x00, 0x00, 0x00, 0xF5, 0x00, 0x07, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
-    0x05, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
-    0xF7, 0x00, 0x03, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0xFA, 0x00, 0x04, 0x00, 0x30, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
-    0x9A, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x31, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00,
-    0x36, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x38, 0x00, 0x00, 0x00,
-    0x39, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x39, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x18, 0x00, 0x00, 0x00, 0x3A, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x00,
-    0x3A, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x3C, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x3D, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x45, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00,
-    0x44, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x3F, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x41, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00,
-    0xDA, 0x00, 0x01, 0x00, 0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x49, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x38, 0x00, 0x00, 0x00, 0x4A, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x4A, 0x00, 0x00, 0x00,
-    0x49, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x4B, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x4C, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x3C, 0x00, 0x00, 0x00, 0x4D, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x4D, 0x00, 0x00, 0x00,
-    0x4C, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x45, 0x00, 0x00, 0x00,
-    0x4E, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x00, 0x00,
-    0x4E, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x41, 0x00, 0x00, 0x00,
-    0x4F, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0x16, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x38, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00,
-    0x35, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x52, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0x16, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00,
-    0x35, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x55, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x45, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
-    0x16, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x3F, 0x00, 0x00, 0x00,
-    0x57, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x41, 0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00,
-    0xDB, 0x00, 0x01, 0x00, 0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00,
-    0x58, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x59, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x38, 0x00, 0x00, 0x00, 0x5A, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x5A, 0x00, 0x00, 0x00,
-    0x59, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x5B, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x5C, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x3C, 0x00, 0x00, 0x00, 0x5D, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x5D, 0x00, 0x00, 0x00,
-    0x5C, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x45, 0x00, 0x00, 0x00,
-    0x5E, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x00,
-    0x5E, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x41, 0x00, 0x00, 0x00,
-    0x5F, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x38, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00,
-    0x35, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x62, 0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00,
-    0x35, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x65, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x45, 0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x3F, 0x00, 0x00, 0x00,
-    0x67, 0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x41, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00,
-    0x68, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00,
-    0x6A, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x04, 0x00,
-    0x11, 0x00, 0x00, 0x00, 0x6B, 0x00, 0x00, 0x00, 0x6A, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0x6C, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x6D, 0x00, 0x00, 0x00,
-    0x6C, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00,
-    0x6E, 0x00, 0x00, 0x00, 0x6D, 0x00, 0x00, 0x00, 0x6D, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x02, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x04, 0x00, 0x1D, 0x00, 0x00, 0x00,
+    0x1C, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00,
+    0x1E, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x04, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x1D, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x21, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x23, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
+    0x23, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x04, 0x00, 0x23, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x1E, 0x00, 0x00, 0x00,
+    0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x27, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x04, 0x00, 0x23, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x1E, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x6F, 0x12, 0x83, 0x3A,
+    0x20, 0x00, 0x04, 0x00, 0x31, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x1C, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x04, 0x00, 0x4A, 0x00, 0x00, 0x00,
+    0x1C, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x4B, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x4A, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x04, 0x00, 0x4B, 0x00, 0x00, 0x00, 0x4C, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x4F, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x53, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x04, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x56, 0x00, 0x00, 0x00,
+    0x1C, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x57, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x04, 0x00, 0x57, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x59, 0x00, 0x00, 0x00,
+    0x56, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x5A, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x04, 0x00, 0x5A, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x5C, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
+    0x23, 0x00, 0x00, 0x00, 0x9F, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x1C, 0x00, 0x04, 0x00, 0x0A, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x1F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x0B, 0x01, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x0A, 0x01, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
+    0x0B, 0x01, 0x00, 0x00, 0x0C, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x1C, 0x00, 0x04, 0x00, 0x0D, 0x01, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x1F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x0E, 0x01, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x0D, 0x01, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
+    0x0E, 0x01, 0x00, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x04, 0x00, 0x10, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x10, 0x01, 0x00, 0x00,
+    0x11, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x05, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x25, 0x01, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00,
+    0x2F, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0xF8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00, 0x41, 0x00, 0x07, 0x00,
+    0x27, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x25, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
+    0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
+    0x28, 0x00, 0x00, 0x00, 0x41, 0x00, 0x07, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x2C, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0x24, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00,
+    0x50, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00,
+    0x29, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
+    0x31, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x24, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x1C, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
+    0x4F, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
+    0x33, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x16, 0x01, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00,
+    0x0C, 0x00, 0x06, 0x00, 0x07, 0x00, 0x00, 0x00, 0x17, 0x01, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x16, 0x01, 0x00, 0x00,
+    0xBC, 0x00, 0x05, 0x00, 0x17, 0x00, 0x00, 0x00, 0x1A, 0x01, 0x00, 0x00,
+    0x17, 0x01, 0x00, 0x00, 0x25, 0x01, 0x00, 0x00, 0x9B, 0x00, 0x04, 0x00,
+    0x0A, 0x00, 0x00, 0x00, 0x1B, 0x01, 0x00, 0x00, 0x1A, 0x01, 0x00, 0x00,
+    0xA8, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
+    0x1B, 0x01, 0x00, 0x00, 0xF7, 0x00, 0x03, 0x00, 0x3A, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x04, 0x00, 0x38, 0x00, 0x00, 0x00,
+    0x39, 0x00, 0x00, 0x00, 0x3A, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
+    0x39, 0x00, 0x00, 0x00, 0x41, 0x00, 0x07, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0x24, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x07, 0x00, 0x27, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x00, 0x00, 0x50, 0x00, 0x05, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x1F, 0x01, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00,
+    0x0C, 0x00, 0x06, 0x00, 0x07, 0x00, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1F, 0x01, 0x00, 0x00,
+    0xBC, 0x00, 0x05, 0x00, 0x17, 0x00, 0x00, 0x00, 0x23, 0x01, 0x00, 0x00,
+    0x20, 0x01, 0x00, 0x00, 0x25, 0x01, 0x00, 0x00, 0x9B, 0x00, 0x04, 0x00,
+    0x0A, 0x00, 0x00, 0x00, 0x24, 0x01, 0x00, 0x00, 0x23, 0x01, 0x00, 0x00,
+    0xF9, 0x00, 0x02, 0x00, 0x3A, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
+    0x3A, 0x00, 0x00, 0x00, 0xF5, 0x00, 0x07, 0x00, 0x0A, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x00, 0x00, 0x1B, 0x01, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x24, 0x01, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0xF7, 0x00, 0x03, 0x00,
+    0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x04, 0x00,
+    0x47, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0xB1, 0x00, 0x00, 0x00,
+    0xF8, 0x00, 0x02, 0x00, 0x48, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
+    0x4F, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x4C, 0x00, 0x00, 0x00,
+    0x24, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x50, 0x00, 0x00, 0x00,
+    0x33, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x51, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+    0x2A, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x52, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
+    0x53, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x4C, 0x00, 0x00, 0x00,
+    0x2A, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x54, 0x00, 0x00, 0x00,
+    0x52, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x5C, 0x00, 0x00, 0x00,
+    0x5D, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+    0x3D, 0x00, 0x04, 0x00, 0x56, 0x00, 0x00, 0x00, 0x5E, 0x00, 0x00, 0x00,
+    0x5D, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x58, 0x00, 0x00, 0x00,
+    0x5E, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00, 0x41, 0x00, 0x06, 0x00,
+    0x31, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x2A, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x1C, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x50, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x06, 0x00, 0x27, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00,
+    0x62, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x54, 0x00, 0x00, 0x00,
+    0x63, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x5C, 0x00, 0x00, 0x00,
+    0x65, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0x3D, 0x00, 0x04, 0x00, 0x56, 0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00,
+    0x65, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x58, 0x00, 0x00, 0x00,
+    0x66, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00, 0x41, 0x00, 0x06, 0x00,
+    0x31, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x25, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x1C, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x50, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x06, 0x00, 0x27, 0x00, 0x00, 0x00, 0x6A, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x6B, 0x00, 0x00, 0x00,
+    0x6A, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x54, 0x00, 0x00, 0x00,
+    0x6B, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x5C, 0x00, 0x00, 0x00,
+    0x6D, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x3D, 0x00, 0x04, 0x00, 0x56, 0x00, 0x00, 0x00, 0x6E, 0x00, 0x00, 0x00,
+    0x6D, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x58, 0x00, 0x00, 0x00,
+    0x6E, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00, 0xDB, 0x00, 0x01, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x50, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x54, 0x00, 0x00, 0x00, 0x6B, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x58, 0x00, 0x00, 0x00, 0x6E, 0x00, 0x00, 0x00,
+    0xDA, 0x00, 0x01, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x50, 0x00, 0x00, 0x00,
+    0x60, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x54, 0x00, 0x00, 0x00,
+    0x63, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x58, 0x00, 0x00, 0x00,
+    0x66, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00, 0x7F, 0x00, 0x04, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
+    0x4F, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00,
+    0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x86, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00,
+    0x4F, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00,
+    0x68, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x8A, 0x00, 0x00, 0x00, 0x86, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00,
+    0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x8E, 0x00, 0x00, 0x00,
+    0x8A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x8F, 0x00, 0x00, 0x00, 0x8A, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x90, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00,
+    0x68, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00,
+    0x1C, 0x00, 0x00, 0x00, 0x92, 0x00, 0x00, 0x00, 0x8E, 0x00, 0x00, 0x00,
+    0x8F, 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x50, 0x00, 0x00, 0x00, 0x92, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x54, 0x00, 0x00, 0x00, 0x6B, 0x00, 0x00, 0x00,
+    0xF9, 0x00, 0x02, 0x00, 0x99, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
+    0x99, 0x00, 0x00, 0x00, 0xF5, 0x00, 0x07, 0x00, 0x23, 0x00, 0x00, 0x00,
+    0x27, 0x01, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
+    0xB0, 0x00, 0x00, 0x00, 0x9A, 0x00, 0x00, 0x00, 0xB1, 0x00, 0x05, 0x00,
+    0x0A, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x27, 0x01, 0x00, 0x00,
+    0x9F, 0x00, 0x00, 0x00, 0xF6, 0x00, 0x04, 0x00, 0x9B, 0x00, 0x00, 0x00,
+    0x9A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x04, 0x00,
+    0xA0, 0x00, 0x00, 0x00, 0x9A, 0x00, 0x00, 0x00, 0x9B, 0x00, 0x00, 0x00,
+    0xF8, 0x00, 0x02, 0x00, 0x9A, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
+    0x31, 0x00, 0x00, 0x00, 0xA3, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00, 0x00,
+    0x24, 0x00, 0x00, 0x00, 0x27, 0x01, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x1C, 0x00, 0x00, 0x00, 0xA4, 0x00, 0x00, 0x00, 0xA3, 0x00, 0x00, 0x00,
+    0x7F, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xA5, 0x00, 0x00, 0x00,
+    0xA4, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x31, 0x00, 0x00, 0x00,
+    0xA7, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0x27, 0x01, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00,
+    0xA8, 0x00, 0x00, 0x00, 0xA7, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00,
+    0x1C, 0x00, 0x00, 0x00, 0xA9, 0x00, 0x00, 0x00, 0xA5, 0x00, 0x00, 0x00,
+    0xA8, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x31, 0x00, 0x00, 0x00,
+    0xAB, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x27, 0x01, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00,
+    0xAC, 0x00, 0x00, 0x00, 0xAB, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00,
+    0x1C, 0x00, 0x00, 0x00, 0xAD, 0x00, 0x00, 0x00, 0xA9, 0x00, 0x00, 0x00,
+    0xAC, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x4F, 0x00, 0x00, 0x00,
+    0xAE, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x27, 0x01, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0xAE, 0x00, 0x00, 0x00, 0xAD, 0x00, 0x00, 0x00,
+    0x80, 0x00, 0x05, 0x00, 0x23, 0x00, 0x00, 0x00, 0xB0, 0x00, 0x00, 0x00,
+    0x27, 0x01, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00,
+    0x99, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x9B, 0x00, 0x00, 0x00,
+    0xDA, 0x00, 0x01, 0x00, 0xDB, 0x00, 0x01, 0x00, 0xF9, 0x00, 0x02, 0x00,
+    0x49, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0xB1, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x05, 0x00, 0x4F, 0x00, 0x00, 0x00, 0xB4, 0x00, 0x00, 0x00,
+    0x4C, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0xB4, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
+    0x27, 0x00, 0x00, 0x00, 0xB5, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x24, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0xB6, 0x00, 0x00, 0x00, 0xB5, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x05, 0x00, 0x53, 0x00, 0x00, 0x00, 0xB7, 0x00, 0x00, 0x00,
+    0x4C, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0xB7, 0x00, 0x00, 0x00, 0xB6, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
+    0x5C, 0x00, 0x00, 0x00, 0xB8, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00, 0x00,
+    0x24, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x56, 0x00, 0x00, 0x00,
+    0xB9, 0x00, 0x00, 0x00, 0xB8, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0x58, 0x00, 0x00, 0x00, 0xB9, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00,
+    0x41, 0x00, 0x06, 0x00, 0x31, 0x00, 0x00, 0x00, 0xBA, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+    0x3D, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xBB, 0x00, 0x00, 0x00,
+    0xBA, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0xB4, 0x00, 0x00, 0x00,
+    0xBB, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0xBD, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0x2A, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0xBE, 0x00, 0x00, 0x00, 0xBD, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0xB7, 0x00, 0x00, 0x00, 0xBE, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
+    0x5C, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00, 0x00,
+    0x2A, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x56, 0x00, 0x00, 0x00,
+    0xC1, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0x58, 0x00, 0x00, 0x00, 0xC1, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00,
+    0x41, 0x00, 0x06, 0x00, 0x31, 0x00, 0x00, 0x00, 0xC2, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+    0x3D, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xC3, 0x00, 0x00, 0x00,
+    0xC2, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0xB4, 0x00, 0x00, 0x00,
+    0xC3, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0xC5, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x2A, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0xC6, 0x00, 0x00, 0x00, 0xC5, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0xB7, 0x00, 0x00, 0x00, 0xC6, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
+    0x5C, 0x00, 0x00, 0x00, 0xC8, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00, 0x00,
+    0x25, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x56, 0x00, 0x00, 0x00,
+    0xC9, 0x00, 0x00, 0x00, 0xC8, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0x58, 0x00, 0x00, 0x00, 0xC9, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00,
+    0xDB, 0x00, 0x01, 0x00, 0x3E, 0x00, 0x03, 0x00, 0xB4, 0x00, 0x00, 0x00,
+    0x33, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0xB7, 0x00, 0x00, 0x00,
+    0xB6, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x58, 0x00, 0x00, 0x00,
+    0xB9, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0xB4, 0x00, 0x00, 0x00, 0xC3, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0xB7, 0x00, 0x00, 0x00, 0xC6, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0x58, 0x00, 0x00, 0x00, 0xC9, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00,
+    0x4F, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0xDF, 0x00, 0x00, 0x00,
+    0xBB, 0x00, 0x00, 0x00, 0xBB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0xE0, 0x00, 0x00, 0x00, 0xDF, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0xE1, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
+    0xE0, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0xE4, 0x00, 0x00, 0x00, 0xC3, 0x00, 0x00, 0x00, 0xC3, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00,
-    0x11, 0x00, 0x00, 0x00, 0x6F, 0x00, 0x00, 0x00, 0x6B, 0x00, 0x00, 0x00,
-    0x6E, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00,
-    0x70, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x71, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00,
-    0x11, 0x00, 0x00, 0x00, 0x72, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00,
-    0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x81, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x73, 0x00, 0x00, 0x00,
-    0x6F, 0x00, 0x00, 0x00, 0x72, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0x16, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00,
-    0x4F, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x76, 0x00, 0x00, 0x00,
-    0x75, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x77, 0x00, 0x00, 0x00, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x51, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00,
-    0x73, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x79, 0x00, 0x00, 0x00, 0x76, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x7A, 0x00, 0x00, 0x00, 0x76, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x50, 0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x00, 0x7B, 0x00, 0x00, 0x00,
-    0x77, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x79, 0x00, 0x00, 0x00,
-    0x7A, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x38, 0x00, 0x00, 0x00,
-    0x7C, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x7B, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x18, 0x00, 0x00, 0x00, 0x7D, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00,
-    0x7D, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x3C, 0x00, 0x00, 0x00,
-    0x7F, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x81, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0xF9, 0x00, 0x02, 0x00, 0x82, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
-    0x82, 0x00, 0x00, 0x00, 0xF6, 0x00, 0x04, 0x00, 0x84, 0x00, 0x00, 0x00,
-    0x85, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00,
-    0x86, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x86, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x87, 0x00, 0x00, 0x00,
-    0x81, 0x00, 0x00, 0x00, 0xB1, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x89, 0x00, 0x00, 0x00, 0x87, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00,
-    0xFA, 0x00, 0x04, 0x00, 0x89, 0x00, 0x00, 0x00, 0x83, 0x00, 0x00, 0x00,
-    0x84, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x83, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x8A, 0x00, 0x00, 0x00,
-    0x81, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00,
-    0x8B, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x8C, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x8B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x8D, 0x00, 0x00, 0x00, 0x8C, 0x00, 0x00, 0x00,
-    0x7F, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x8E, 0x00, 0x00, 0x00,
-    0x8D, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00,
-    0x8F, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x8F, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00,
-    0x81, 0x00, 0x05, 0x00, 0x08, 0x00, 0x00, 0x00, 0x92, 0x00, 0x00, 0x00,
-    0x8E, 0x00, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x0F, 0x00, 0x00, 0x00, 0x93, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00,
-    0x44, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x93, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00,
-    0x94, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x96, 0x00, 0x00, 0x00, 0x92, 0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x38, 0x00, 0x00, 0x00, 0x97, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x00, 0x00, 0x8A, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x97, 0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00,
-    0x85, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x85, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00,
-    0x81, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, 0x0F, 0x00, 0x00, 0x00,
-    0x99, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x81, 0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00,
-    0xF9, 0x00, 0x02, 0x00, 0x82, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
-    0x84, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00, 0xDB, 0x00, 0x01, 0x00,
-    0xF9, 0x00, 0x02, 0x00, 0x32, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
-    0x9A, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00,
-    0x9B, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x9C, 0x00, 0x00, 0x00, 0x9B, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x38, 0x00, 0x00, 0x00, 0x9D, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x9D, 0x00, 0x00, 0x00,
-    0x9C, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x9E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x9F, 0x00, 0x00, 0x00, 0x9E, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x3C, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0xA0, 0x00, 0x00, 0x00,
-    0x9F, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x45, 0x00, 0x00, 0x00,
-    0xA1, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x3F, 0x00, 0x00, 0x00, 0xA2, 0x00, 0x00, 0x00,
-    0xA1, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x41, 0x00, 0x00, 0x00,
-    0xA2, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0xA3, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0xA4, 0x00, 0x00, 0x00, 0xA3, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x38, 0x00, 0x00, 0x00, 0xA5, 0x00, 0x00, 0x00,
-    0x35, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0xA5, 0x00, 0x00, 0x00, 0xA4, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0xA6, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0xA7, 0x00, 0x00, 0x00, 0xA6, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x3C, 0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00,
-    0x35, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0xA8, 0x00, 0x00, 0x00, 0xA7, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x45, 0x00, 0x00, 0x00, 0xA9, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x3F, 0x00, 0x00, 0x00,
-    0xAA, 0x00, 0x00, 0x00, 0xA9, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x41, 0x00, 0x00, 0x00, 0xAA, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0xAB, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0xAC, 0x00, 0x00, 0x00,
-    0xAB, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x38, 0x00, 0x00, 0x00,
-    0xAD, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0xAD, 0x00, 0x00, 0x00, 0xAC, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x18, 0x00, 0x00, 0x00, 0xAE, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0xAF, 0x00, 0x00, 0x00,
-    0xAE, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x3C, 0x00, 0x00, 0x00,
-    0xB0, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0xB0, 0x00, 0x00, 0x00, 0xAF, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x45, 0x00, 0x00, 0x00, 0xB1, 0x00, 0x00, 0x00,
-    0x44, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x3F, 0x00, 0x00, 0x00, 0xB2, 0x00, 0x00, 0x00, 0xB1, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x41, 0x00, 0x00, 0x00, 0xB2, 0x00, 0x00, 0x00,
-    0xDA, 0x00, 0x01, 0x00, 0xDB, 0x00, 0x01, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0xB3, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0xB4, 0x00, 0x00, 0x00, 0xB3, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x38, 0x00, 0x00, 0x00, 0xB5, 0x00, 0x00, 0x00,
-    0x35, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0xB5, 0x00, 0x00, 0x00, 0xB4, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0xB6, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0xB7, 0x00, 0x00, 0x00, 0xB6, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x3C, 0x00, 0x00, 0x00, 0xB8, 0x00, 0x00, 0x00,
-    0x35, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0xB8, 0x00, 0x00, 0x00, 0xB7, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x45, 0x00, 0x00, 0x00, 0xB9, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x3F, 0x00, 0x00, 0x00,
-    0xBA, 0x00, 0x00, 0x00, 0xB9, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x41, 0x00, 0x00, 0x00, 0xBA, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0xBB, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0xBC, 0x00, 0x00, 0x00,
-    0xBB, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x38, 0x00, 0x00, 0x00,
-    0xBD, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0xBD, 0x00, 0x00, 0x00, 0xBC, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x18, 0x00, 0x00, 0x00, 0xBE, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0xBF, 0x00, 0x00, 0x00,
-    0xBE, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x3C, 0x00, 0x00, 0x00,
-    0xC0, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xBF, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x45, 0x00, 0x00, 0x00, 0xC1, 0x00, 0x00, 0x00,
-    0x44, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x3F, 0x00, 0x00, 0x00, 0xC2, 0x00, 0x00, 0x00, 0xC1, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x41, 0x00, 0x00, 0x00, 0xC2, 0x00, 0x00, 0x00,
-    0xDA, 0x00, 0x01, 0x00, 0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00,
-    0xC3, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0xC4, 0x00, 0x00, 0x00, 0xC3, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00,
-    0x11, 0x00, 0x00, 0x00, 0xC5, 0x00, 0x00, 0x00, 0xC4, 0x00, 0x00, 0x00,
-    0xC4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0xC6, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0xC7, 0x00, 0x00, 0x00,
-    0xC6, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00,
-    0xC8, 0x00, 0x00, 0x00, 0xC7, 0x00, 0x00, 0x00, 0xC7, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x04, 0x00,
-    0x11, 0x00, 0x00, 0x00, 0xC9, 0x00, 0x00, 0x00, 0xC8, 0x00, 0x00, 0x00,
-    0x81, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xCA, 0x00, 0x00, 0x00,
-    0xC5, 0x00, 0x00, 0x00, 0xC9, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
-    0x16, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0xCC, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x00, 0x00,
-    0x4F, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x00,
-    0xCC, 0x00, 0x00, 0x00, 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00,
-    0xCE, 0x00, 0x00, 0x00, 0xCA, 0x00, 0x00, 0x00, 0xCD, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0xCF, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0xD0, 0x00, 0x00, 0x00,
-    0xCF, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00,
-    0xD1, 0x00, 0x00, 0x00, 0xD0, 0x00, 0x00, 0x00, 0xD0, 0x00, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0xD2, 0x00, 0x00, 0x00, 0xCE, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0xD3, 0x00, 0x00, 0x00, 0xCE, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x51, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0xD4, 0x00, 0x00, 0x00,
-    0xD1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0xD5, 0x00, 0x00, 0x00, 0xD1, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0xD6, 0x00, 0x00, 0x00, 0xD2, 0x00, 0x00, 0x00, 0xD3, 0x00, 0x00, 0x00,
-    0xD4, 0x00, 0x00, 0x00, 0xD5, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x38, 0x00, 0x00, 0x00, 0xD7, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0xD7, 0x00, 0x00, 0x00,
-    0xD6, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0xD8, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0xD9, 0x00, 0x00, 0x00, 0xD8, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
-    0x3C, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0xDA, 0x00, 0x00, 0x00,
-    0xD9, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0xDB, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00, 0xDC, 0x00, 0x00, 0x00,
-    0xF8, 0x00, 0x02, 0x00, 0xDC, 0x00, 0x00, 0x00, 0xF6, 0x00, 0x04, 0x00,
-    0xDE, 0x00, 0x00, 0x00, 0xDF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0xF9, 0x00, 0x02, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
-    0xE0, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00,
-    0xE1, 0x00, 0x00, 0x00, 0xDB, 0x00, 0x00, 0x00, 0xB1, 0x00, 0x05, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0xE2, 0x00, 0x00, 0x00, 0xE1, 0x00, 0x00, 0x00,
-    0x88, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x04, 0x00, 0xE2, 0x00, 0x00, 0x00,
-    0xDD, 0x00, 0x00, 0x00, 0xDE, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
-    0xDD, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00,
-    0xE3, 0x00, 0x00, 0x00, 0xDB, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x0F, 0x00, 0x00, 0x00, 0xE4, 0x00, 0x00, 0x00, 0xDB, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0xE5, 0x00, 0x00, 0x00,
-    0x44, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xE4, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0xE6, 0x00, 0x00, 0x00,
-    0xE5, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00,
-    0xE7, 0x00, 0x00, 0x00, 0xDB, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0xE7, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0xE9, 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x00,
-    0x7F, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0xEA, 0x00, 0x00, 0x00,
-    0xE9, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0xEB, 0x00, 0x00, 0x00, 0xE6, 0x00, 0x00, 0x00, 0xEA, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00, 0xEC, 0x00, 0x00, 0x00,
-    0xDB, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00,
-    0xED, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
-    0xEC, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0xEE, 0x00, 0x00, 0x00, 0xED, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0xEF, 0x00, 0x00, 0x00, 0xEB, 0x00, 0x00, 0x00,
-    0xEE, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x38, 0x00, 0x00, 0x00,
-    0xF0, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0xE3, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xEF, 0x00, 0x00, 0x00,
-    0xF9, 0x00, 0x02, 0x00, 0xDF, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
-    0xDF, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00,
-    0xF1, 0x00, 0x00, 0x00, 0xDB, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00,
-    0x0F, 0x00, 0x00, 0x00, 0xF2, 0x00, 0x00, 0x00, 0xF1, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0xDB, 0x00, 0x00, 0x00,
-    0xF2, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00, 0xDC, 0x00, 0x00, 0x00,
-    0xF8, 0x00, 0x02, 0x00, 0xDE, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00,
-    0xDB, 0x00, 0x01, 0x00, 0xF9, 0x00, 0x02, 0x00, 0x32, 0x00, 0x00, 0x00,
-    0xF8, 0x00, 0x02, 0x00, 0x32, 0x00, 0x00, 0x00, 0xFD, 0x00, 0x01, 0x00,
-    0x38, 0x00, 0x01, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0xE5, 0x00, 0x00, 0x00, 0xE1, 0x00, 0x00, 0x00,
+    0xE4, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0xE9, 0x00, 0x00, 0x00, 0xE5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0xEA, 0x00, 0x00, 0x00,
+    0xE5, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0xEB, 0x00, 0x00, 0x00, 0xC3, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0xEC, 0x00, 0x00, 0x00, 0xC3, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x50, 0x00, 0x07, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xED, 0x00, 0x00, 0x00,
+    0xE9, 0x00, 0x00, 0x00, 0xEA, 0x00, 0x00, 0x00, 0xEB, 0x00, 0x00, 0x00,
+    0xEC, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0xB4, 0x00, 0x00, 0x00,
+    0xED, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0xB7, 0x00, 0x00, 0x00,
+    0xC6, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00, 0xF3, 0x00, 0x00, 0x00,
+    0xF8, 0x00, 0x02, 0x00, 0xF3, 0x00, 0x00, 0x00, 0xF5, 0x00, 0x07, 0x00,
+    0x23, 0x00, 0x00, 0x00, 0x26, 0x01, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+    0xB1, 0x00, 0x00, 0x00, 0x09, 0x01, 0x00, 0x00, 0xF4, 0x00, 0x00, 0x00,
+    0xB1, 0x00, 0x05, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x00, 0x00,
+    0x26, 0x01, 0x00, 0x00, 0x9F, 0x00, 0x00, 0x00, 0xF6, 0x00, 0x04, 0x00,
+    0xF5, 0x00, 0x00, 0x00, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xFA, 0x00, 0x04, 0x00, 0xF9, 0x00, 0x00, 0x00, 0xF4, 0x00, 0x00, 0x00,
+    0xF5, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0xF4, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x06, 0x00, 0x31, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00,
+    0x5B, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x26, 0x01, 0x00, 0x00,
+    0x3D, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xFD, 0x00, 0x00, 0x00,
+    0xFC, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x31, 0x00, 0x00, 0x00,
+    0xFF, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0x26, 0x01, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x04, 0x00,
+    0x1C, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x81, 0x00, 0x05, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00,
+    0xFD, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
+    0x31, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x5B, 0x00, 0x00, 0x00,
+    0x25, 0x00, 0x00, 0x00, 0x26, 0x01, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x1C, 0x00, 0x00, 0x00, 0x05, 0x01, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00,
+    0x81, 0x00, 0x05, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x06, 0x01, 0x00, 0x00,
+    0x02, 0x01, 0x00, 0x00, 0x05, 0x01, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
+    0x4F, 0x00, 0x00, 0x00, 0x07, 0x01, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00,
+    0x26, 0x01, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x07, 0x01, 0x00, 0x00,
+    0x06, 0x01, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, 0x23, 0x00, 0x00, 0x00,
+    0x09, 0x01, 0x00, 0x00, 0x26, 0x01, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0xF9, 0x00, 0x02, 0x00, 0xF3, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
+    0xF5, 0x00, 0x00, 0x00, 0xDA, 0x00, 0x01, 0x00, 0xDB, 0x00, 0x01, 0x00,
+    0xF9, 0x00, 0x02, 0x00, 0x49, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
+    0x49, 0x00, 0x00, 0x00, 0xFD, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00,
 };
diff --git a/src/xenia/gpu/vulkan/shaders/bin/rect_list_geom.txt b/src/xenia/gpu/vulkan/shaders/bin/rect_list_geom.txt
index 373600fb6..ff580ea8d 100644
--- a/src/xenia/gpu/vulkan/shaders/bin/rect_list_geom.txt
+++ b/src/xenia/gpu/vulkan/shaders/bin/rect_list_geom.txt
@@ -1,7 +1,7 @@
 ; SPIR-V
 ; Version: 1.0
 ; Generator: Khronos Glslang Reference Front End; 6
-; Bound: 251
+; Bound: 296
 ; Schema: 0
                OpCapability Geometry
                OpCapability GeometryPointSize
@@ -26,8 +26,6 @@
                OpName %_ ""
                OpName %out_interpolators "out_interpolators"
                OpName %in_interpolators "in_interpolators"
-               OpName %i "i"
-               OpName %i_0 "i"
                OpName %_in_point_coord_unused "_in_point_coord_unused"
                OpName %_in_point_size_unused "_in_point_size_unused"
                OpName %_out_point_coord_unused "_out_point_coord_unused"
@@ -44,8 +42,10 @@
                OpDecorate %_out_point_coord_unused Location 16
        %void = OpTypeVoid
           %3 = OpTypeFunction %void
-       %bool = OpTypeBool
       %float = OpTypeFloat 32
+    %v2float = OpTypeVector %float 2
+       %bool = OpTypeBool
+     %v2bool = OpTypeVector %bool 2
     %v4float = OpTypeVector %float 4
 %gl_PerVertex = OpTypeStruct %v4float %float
        %uint = OpTypeInt 32 0
@@ -55,14 +55,13 @@
       %gl_in = OpVariable %_ptr_Input__arr_gl_PerVertex_uint_3 Input
         %int = OpTypeInt 32 1
       %int_0 = OpConstant %int 0
-    %v2float = OpTypeVector %float 2
-%_ptr_Input_v4float = OpTypePointer Input %v4float
       %int_2 = OpConstant %int 2
      %uint_0 = OpConstant %uint 0
 %_ptr_Input_float = OpTypePointer Input %float
       %int_1 = OpConstant %int 1
      %uint_1 = OpConstant %uint 1
-     %v2bool = OpTypeVector %bool 2
+%float_0_00100000005 = OpConstant %float 0.00100000005
+%_ptr_Input_v4float = OpTypePointer Input %v4float
 %gl_PerVertex_0 = OpTypeStruct %v4float %float
 %_ptr_Output_gl_PerVertex_0 = OpTypePointer Output %gl_PerVertex_0
           %_ = OpVariable %_ptr_Output_gl_PerVertex_0 Output
@@ -76,7 +75,6 @@
 %_ptr_Input__arr__arr_v4float_uint_16_uint_3 = OpTypePointer Input %_arr__arr_v4float_uint_16_uint_3
 %in_interpolators = OpVariable %_ptr_Input__arr__arr_v4float_uint_16_uint_3 Input
 %_ptr_Input__arr_v4float_uint_16 = OpTypePointer Input %_arr_v4float_uint_16
-%_ptr_Function_int = OpTypePointer Function %int
      %int_16 = OpConstant %int 16
 %_arr_v2float_uint_3 = OpTypeArray %v2float %uint_3
 %_ptr_Input__arr_v2float_uint_3 = OpTypePointer Input %_arr_v2float_uint_3
@@ -86,285 +84,191 @@
 %_in_point_size_unused = OpVariable %_ptr_Input__arr_float_uint_3 Input
 %_ptr_Output_v2float = OpTypePointer Output %v2float
 %_out_point_coord_unused = OpVariable %_ptr_Output_v2float Output
+        %293 = OpConstantComposite %v2float %float_0_00100000005 %float_0_00100000005
        %main = OpFunction %void None %3
           %5 = OpLabel
-          %i = OpVariable %_ptr_Function_int Function
-        %i_0 = OpVariable %_ptr_Function_int Function
-         %19 = OpAccessChain %_ptr_Input_v4float %gl_in %int_0 %int_0
-         %20 = OpLoad %v4float %19
-         %21 = OpVectorShuffle %v2float %20 %20 0 1
-         %25 = OpAccessChain %_ptr_Input_float %gl_in %int_2 %int_0 %uint_0
-         %26 = OpLoad %float %25
-         %29 = OpAccessChain %_ptr_Input_float %gl_in %int_1 %int_0 %uint_1
-         %30 = OpLoad %float %29
-         %31 = OpCompositeConstruct %v2float %26 %30
-         %33 = OpFOrdEqual %v2bool %21 %31
-         %34 = OpAll %bool %33
-         %35 = OpLogicalNot %bool %34
-               OpSelectionMerge %37 None
-               OpBranchConditional %35 %36 %37
-         %36 = OpLabel
-         %38 = OpAccessChain %_ptr_Input_v4float %gl_in %int_0 %int_0
-         %39 = OpLoad %v4float %38
-         %40 = OpVectorShuffle %v2float %39 %39 0 1
-         %41 = OpAccessChain %_ptr_Input_float %gl_in %int_1 %int_0 %uint_0
-         %42 = OpLoad %float %41
-         %43 = OpAccessChain %_ptr_Input_float %gl_in %int_2 %int_0 %uint_1
-         %44 = OpLoad %float %43
-         %45 = OpCompositeConstruct %v2float %42 %44
-         %46 = OpFOrdEqual %v2bool %40 %45
-         %47 = OpAll %bool %46
-               OpBranch %37
-         %37 = OpLabel
-         %48 = OpPhi %bool %34 %5 %47 %36
-               OpSelectionMerge %50 None
-               OpBranchConditional %48 %49 %154
-         %49 = OpLabel
-         %54 = OpAccessChain %_ptr_Input_v4float %gl_in %int_0 %int_0
-         %55 = OpLoad %v4float %54
-         %57 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %57 %55
-         %58 = OpAccessChain %_ptr_Input_float %gl_in %int_0 %int_1
-         %59 = OpLoad %float %58
-         %61 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %61 %59
-         %70 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_0
-         %71 = OpLoad %_arr_v4float_uint_16 %70
-               OpStore %out_interpolators %71
+         %40 = OpAccessChain %_ptr_Input_float %gl_in %int_2 %int_0 %uint_0
+         %41 = OpLoad %float %40
+         %44 = OpAccessChain %_ptr_Input_float %gl_in %int_1 %int_0 %uint_1
+         %45 = OpLoad %float %44
+         %46 = OpCompositeConstruct %v2float %41 %45
+         %50 = OpAccessChain %_ptr_Input_v4float %gl_in %int_0 %int_0
+         %51 = OpLoad %v4float %50
+         %52 = OpVectorShuffle %v2float %51 %51 0 1
+        %278 = OpFSub %v2float %52 %46
+        %279 = OpExtInst %v2float %1 FAbs %278
+        %282 = OpFOrdLessThanEqual %v2bool %279 %293
+        %283 = OpAll %bool %282
+         %56 = OpLogicalNot %bool %283
+               OpSelectionMerge %58 None
+               OpBranchConditional %56 %57 %58
+         %57 = OpLabel
+         %59 = OpAccessChain %_ptr_Input_float %gl_in %int_1 %int_0 %uint_0
+         %60 = OpLoad %float %59
+         %61 = OpAccessChain %_ptr_Input_float %gl_in %int_2 %int_0 %uint_1
+         %62 = OpLoad %float %61
+         %63 = OpCompositeConstruct %v2float %60 %62
+        %287 = OpFSub %v2float %52 %63
+        %288 = OpExtInst %v2float %1 FAbs %287
+        %291 = OpFOrdLessThanEqual %v2bool %288 %293
+        %292 = OpAll %bool %291
+               OpBranch %58
+         %58 = OpLabel
+         %71 = OpPhi %bool %283 %5 %292 %57
+               OpSelectionMerge %73 None
+               OpBranchConditional %71 %72 %177
+         %72 = OpLabel
+         %80 = OpAccessChain %_ptr_Output_v4float %_ %int_0
+               OpStore %80 %51
+         %81 = OpAccessChain %_ptr_Input_float %gl_in %int_0 %int_1
+         %82 = OpLoad %float %81
+         %84 = OpAccessChain %_ptr_Output_float %_ %int_1
+               OpStore %84 %82
+         %93 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_0
+         %94 = OpLoad %_arr_v4float_uint_16 %93
+               OpStore %out_interpolators %94
                OpEmitVertex
-         %72 = OpAccessChain %_ptr_Input_v4float %gl_in %int_1 %int_0
-         %73 = OpLoad %v4float %72
-         %74 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %74 %73
-         %75 = OpAccessChain %_ptr_Input_float %gl_in %int_1 %int_1
-         %76 = OpLoad %float %75
-         %77 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %77 %76
-         %78 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_1
-         %79 = OpLoad %_arr_v4float_uint_16 %78
-               OpStore %out_interpolators %79
+         %95 = OpAccessChain %_ptr_Input_v4float %gl_in %int_1 %int_0
+         %96 = OpLoad %v4float %95
+               OpStore %80 %96
+         %98 = OpAccessChain %_ptr_Input_float %gl_in %int_1 %int_1
+         %99 = OpLoad %float %98
+               OpStore %84 %99
+        %101 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_1
+        %102 = OpLoad %_arr_v4float_uint_16 %101
+               OpStore %out_interpolators %102
                OpEmitVertex
-         %80 = OpAccessChain %_ptr_Input_v4float %gl_in %int_2 %int_0
-         %81 = OpLoad %v4float %80
-         %82 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %82 %81
-         %83 = OpAccessChain %_ptr_Input_float %gl_in %int_2 %int_1
-         %84 = OpLoad %float %83
-         %85 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %85 %84
-         %86 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_2
-         %87 = OpLoad %_arr_v4float_uint_16 %86
-               OpStore %out_interpolators %87
+        %103 = OpAccessChain %_ptr_Input_v4float %gl_in %int_2 %int_0
+        %104 = OpLoad %v4float %103
+               OpStore %80 %104
+        %106 = OpAccessChain %_ptr_Input_float %gl_in %int_2 %int_1
+        %107 = OpLoad %float %106
+               OpStore %84 %107
+        %109 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_2
+        %110 = OpLoad %_arr_v4float_uint_16 %109
+               OpStore %out_interpolators %110
                OpEmitVertex
                OpEndPrimitive
-         %88 = OpAccessChain %_ptr_Input_v4float %gl_in %int_2 %int_0
-         %89 = OpLoad %v4float %88
-         %90 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %90 %89
-         %91 = OpAccessChain %_ptr_Input_float %gl_in %int_2 %int_1
-         %92 = OpLoad %float %91
-         %93 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %93 %92
-         %94 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_2
-         %95 = OpLoad %_arr_v4float_uint_16 %94
-               OpStore %out_interpolators %95
+               OpStore %80 %104
+               OpStore %84 %107
+               OpStore %out_interpolators %110
                OpEmitVertex
-         %96 = OpAccessChain %_ptr_Input_v4float %gl_in %int_1 %int_0
-         %97 = OpLoad %v4float %96
-         %98 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %98 %97
-         %99 = OpAccessChain %_ptr_Input_float %gl_in %int_1 %int_1
-        %100 = OpLoad %float %99
-        %101 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %101 %100
-        %102 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_1
-        %103 = OpLoad %_arr_v4float_uint_16 %102
-               OpStore %out_interpolators %103
+               OpStore %80 %96
+               OpStore %84 %99
+               OpStore %out_interpolators %102
                OpEmitVertex
-        %104 = OpAccessChain %_ptr_Input_v4float %gl_in %int_0 %int_0
-        %105 = OpLoad %v4float %104
-        %106 = OpVectorShuffle %v2float %105 %105 0 1
-        %107 = OpFNegate %v2float %106
-        %108 = OpAccessChain %_ptr_Input_v4float %gl_in %int_1 %int_0
-        %109 = OpLoad %v4float %108
-        %110 = OpVectorShuffle %v2float %109 %109 0 1
-        %111 = OpFAdd %v2float %107 %110
-        %112 = OpAccessChain %_ptr_Input_v4float %gl_in %int_2 %int_0
-        %113 = OpLoad %v4float %112
-        %114 = OpVectorShuffle %v2float %113 %113 0 1
-        %115 = OpFAdd %v2float %111 %114
-        %116 = OpAccessChain %_ptr_Input_v4float %gl_in %int_2 %int_0
-        %117 = OpLoad %v4float %116
-        %118 = OpVectorShuffle %v2float %117 %117 2 3
-        %119 = OpCompositeExtract %float %115 0
-        %120 = OpCompositeExtract %float %115 1
-        %121 = OpCompositeExtract %float %118 0
-        %122 = OpCompositeExtract %float %118 1
-        %123 = OpCompositeConstruct %v4float %119 %120 %121 %122
-        %124 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %124 %123
-        %125 = OpAccessChain %_ptr_Input_float %gl_in %int_2 %int_1
-        %126 = OpLoad %float %125
-        %127 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %127 %126
-               OpStore %i %int_0
-               OpBranch %130
-        %130 = OpLabel
-               OpLoopMerge %132 %133 None
-               OpBranch %134
-        %134 = OpLabel
-        %135 = OpLoad %int %i
-        %137 = OpSLessThan %bool %135 %int_16
-               OpBranchConditional %137 %131 %132
-        %131 = OpLabel
-        %138 = OpLoad %int %i
-        %139 = OpLoad %int %i
-        %140 = OpAccessChain %_ptr_Input_v4float %in_interpolators %int_0 %139
-        %141 = OpLoad %v4float %140
-        %142 = OpFNegate %v4float %141
-        %143 = OpLoad %int %i
-        %144 = OpAccessChain %_ptr_Input_v4float %in_interpolators %int_1 %143
-        %145 = OpLoad %v4float %144
-        %146 = OpFAdd %v4float %142 %145
-        %147 = OpLoad %int %i
-        %148 = OpAccessChain %_ptr_Input_v4float %in_interpolators %int_2 %147
-        %149 = OpLoad %v4float %148
-        %150 = OpFAdd %v4float %146 %149
-        %151 = OpAccessChain %_ptr_Output_v4float %out_interpolators %138
-               OpStore %151 %150
-               OpBranch %133
-        %133 = OpLabel
-        %152 = OpLoad %int %i
-        %153 = OpIAdd %int %152 %int_1
-               OpStore %i %153
-               OpBranch %130
-        %132 = OpLabel
-               OpEmitVertex
-               OpEndPrimitive
-               OpBranch %50
+        %130 = OpFNegate %v2float %52
+        %133 = OpVectorShuffle %v2float %96 %96 0 1
+        %134 = OpFAdd %v2float %130 %133
+        %137 = OpVectorShuffle %v2float %104 %104 0 1
+        %138 = OpFAdd %v2float %134 %137
+        %142 = OpCompositeExtract %float %138 0
+        %143 = OpCompositeExtract %float %138 1
+        %144 = OpCompositeExtract %float %104 2
+        %145 = OpCompositeExtract %float %104 3
+        %146 = OpCompositeConstruct %v4float %142 %143 %144 %145
+               OpStore %80 %146
+               OpStore %84 %107
+               OpBranch %153
+        %153 = OpLabel
+        %295 = OpPhi %int %int_0 %72 %176 %154
+        %160 = OpSLessThan %bool %295 %int_16
+               OpLoopMerge %155 %154 None
+               OpBranchConditional %160 %154 %155
         %154 = OpLabel
-        %155 = OpAccessChain %_ptr_Input_v4float %gl_in %int_0 %int_0
-        %156 = OpLoad %v4float %155
-        %157 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %157 %156
-        %158 = OpAccessChain %_ptr_Input_float %gl_in %int_0 %int_1
-        %159 = OpLoad %float %158
-        %160 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %160 %159
-        %161 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_0
-        %162 = OpLoad %_arr_v4float_uint_16 %161
-               OpStore %out_interpolators %162
-               OpEmitVertex
-        %163 = OpAccessChain %_ptr_Input_v4float %gl_in %int_1 %int_0
+        %163 = OpAccessChain %_ptr_Input_v4float %in_interpolators %int_0 %295
         %164 = OpLoad %v4float %163
-        %165 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %165 %164
-        %166 = OpAccessChain %_ptr_Input_float %gl_in %int_1 %int_1
-        %167 = OpLoad %float %166
-        %168 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %168 %167
-        %169 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_1
-        %170 = OpLoad %_arr_v4float_uint_16 %169
-               OpStore %out_interpolators %170
-               OpEmitVertex
-        %171 = OpAccessChain %_ptr_Input_v4float %gl_in %int_2 %int_0
+        %165 = OpFNegate %v4float %164
+        %167 = OpAccessChain %_ptr_Input_v4float %in_interpolators %int_1 %295
+        %168 = OpLoad %v4float %167
+        %169 = OpFAdd %v4float %165 %168
+        %171 = OpAccessChain %_ptr_Input_v4float %in_interpolators %int_2 %295
         %172 = OpLoad %v4float %171
-        %173 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %173 %172
-        %174 = OpAccessChain %_ptr_Input_float %gl_in %int_2 %int_1
-        %175 = OpLoad %float %174
-        %176 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %176 %175
-        %177 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_2
-        %178 = OpLoad %_arr_v4float_uint_16 %177
-               OpStore %out_interpolators %178
+        %173 = OpFAdd %v4float %169 %172
+        %174 = OpAccessChain %_ptr_Output_v4float %out_interpolators %295
+               OpStore %174 %173
+        %176 = OpIAdd %int %295 %int_1
+               OpBranch %153
+        %155 = OpLabel
                OpEmitVertex
                OpEndPrimitive
-        %179 = OpAccessChain %_ptr_Input_v4float %gl_in %int_0 %int_0
-        %180 = OpLoad %v4float %179
-        %181 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %181 %180
-        %182 = OpAccessChain %_ptr_Input_float %gl_in %int_0 %int_1
-        %183 = OpLoad %float %182
-        %184 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %184 %183
-        %185 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_0
-        %186 = OpLoad %_arr_v4float_uint_16 %185
-               OpStore %out_interpolators %186
+               OpBranch %73
+        %177 = OpLabel
+        %180 = OpAccessChain %_ptr_Output_v4float %_ %int_0
+               OpStore %180 %51
+        %181 = OpAccessChain %_ptr_Input_float %gl_in %int_0 %int_1
+        %182 = OpLoad %float %181
+        %183 = OpAccessChain %_ptr_Output_float %_ %int_1
+               OpStore %183 %182
+        %184 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_0
+        %185 = OpLoad %_arr_v4float_uint_16 %184
+               OpStore %out_interpolators %185
                OpEmitVertex
-        %187 = OpAccessChain %_ptr_Input_v4float %gl_in %int_2 %int_0
-        %188 = OpLoad %v4float %187
-        %189 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %189 %188
-        %190 = OpAccessChain %_ptr_Input_float %gl_in %int_2 %int_1
-        %191 = OpLoad %float %190
-        %192 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %192 %191
-        %193 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_2
-        %194 = OpLoad %_arr_v4float_uint_16 %193
-               OpStore %out_interpolators %194
+        %186 = OpAccessChain %_ptr_Input_v4float %gl_in %int_1 %int_0
+        %187 = OpLoad %v4float %186
+               OpStore %180 %187
+        %189 = OpAccessChain %_ptr_Input_float %gl_in %int_1 %int_1
+        %190 = OpLoad %float %189
+               OpStore %183 %190
+        %192 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_1
+        %193 = OpLoad %_arr_v4float_uint_16 %192
+               OpStore %out_interpolators %193
                OpEmitVertex
-        %195 = OpAccessChain %_ptr_Input_v4float %gl_in %int_0 %int_0
-        %196 = OpLoad %v4float %195
-        %197 = OpVectorShuffle %v2float %196 %196 0 1
-        %198 = OpAccessChain %_ptr_Input_v4float %gl_in %int_1 %int_0
-        %199 = OpLoad %v4float %198
-        %200 = OpVectorShuffle %v2float %199 %199 0 1
-        %201 = OpFNegate %v2float %200
-        %202 = OpFAdd %v2float %197 %201
-        %203 = OpAccessChain %_ptr_Input_v4float %gl_in %int_2 %int_0
-        %204 = OpLoad %v4float %203
-        %205 = OpVectorShuffle %v2float %204 %204 0 1
-        %206 = OpFAdd %v2float %202 %205
-        %207 = OpAccessChain %_ptr_Input_v4float %gl_in %int_2 %int_0
-        %208 = OpLoad %v4float %207
-        %209 = OpVectorShuffle %v2float %208 %208 2 3
-        %210 = OpCompositeExtract %float %206 0
-        %211 = OpCompositeExtract %float %206 1
-        %212 = OpCompositeExtract %float %209 0
-        %213 = OpCompositeExtract %float %209 1
-        %214 = OpCompositeConstruct %v4float %210 %211 %212 %213
-        %215 = OpAccessChain %_ptr_Output_v4float %_ %int_0
-               OpStore %215 %214
-        %216 = OpAccessChain %_ptr_Input_float %gl_in %int_2 %int_1
-        %217 = OpLoad %float %216
-        %218 = OpAccessChain %_ptr_Output_float %_ %int_1
-               OpStore %218 %217
-               OpStore %i_0 %int_0
-               OpBranch %220
-        %220 = OpLabel
-               OpLoopMerge %222 %223 None
-               OpBranch %224
-        %224 = OpLabel
-        %225 = OpLoad %int %i_0
-        %226 = OpSLessThan %bool %225 %int_16
-               OpBranchConditional %226 %221 %222
-        %221 = OpLabel
-        %227 = OpLoad %int %i_0
-        %228 = OpLoad %int %i_0
-        %229 = OpAccessChain %_ptr_Input_v4float %in_interpolators %int_0 %228
-        %230 = OpLoad %v4float %229
-        %231 = OpLoad %int %i_0
-        %232 = OpAccessChain %_ptr_Input_v4float %in_interpolators %int_1 %231
-        %233 = OpLoad %v4float %232
-        %234 = OpFNegate %v4float %233
-        %235 = OpFAdd %v4float %230 %234
-        %236 = OpLoad %int %i_0
-        %237 = OpAccessChain %_ptr_Input_v4float %in_interpolators %int_2 %236
-        %238 = OpLoad %v4float %237
-        %239 = OpFAdd %v4float %235 %238
-        %240 = OpAccessChain %_ptr_Output_v4float %out_interpolators %227
-               OpStore %240 %239
-               OpBranch %223
-        %223 = OpLabel
-        %241 = OpLoad %int %i_0
-        %242 = OpIAdd %int %241 %int_1
-               OpStore %i_0 %242
-               OpBranch %220
-        %222 = OpLabel
+        %194 = OpAccessChain %_ptr_Input_v4float %gl_in %int_2 %int_0
+        %195 = OpLoad %v4float %194
+               OpStore %180 %195
+        %197 = OpAccessChain %_ptr_Input_float %gl_in %int_2 %int_1
+        %198 = OpLoad %float %197
+               OpStore %183 %198
+        %200 = OpAccessChain %_ptr_Input__arr_v4float_uint_16 %in_interpolators %int_2
+        %201 = OpLoad %_arr_v4float_uint_16 %200
+               OpStore %out_interpolators %201
                OpEmitVertex
                OpEndPrimitive
-               OpBranch %50
-         %50 = OpLabel
+               OpStore %180 %51
+               OpStore %183 %182
+               OpStore %out_interpolators %185
+               OpEmitVertex
+               OpStore %180 %195
+               OpStore %183 %198
+               OpStore %out_interpolators %201
+               OpEmitVertex
+        %223 = OpVectorShuffle %v2float %187 %187 0 1
+        %224 = OpFNegate %v2float %223
+        %225 = OpFAdd %v2float %52 %224
+        %228 = OpVectorShuffle %v2float %195 %195 0 1
+        %229 = OpFAdd %v2float %225 %228
+        %233 = OpCompositeExtract %float %229 0
+        %234 = OpCompositeExtract %float %229 1
+        %235 = OpCompositeExtract %float %195 2
+        %236 = OpCompositeExtract %float %195 3
+        %237 = OpCompositeConstruct %v4float %233 %234 %235 %236
+               OpStore %180 %237
+               OpStore %183 %198
+               OpBranch %243
+        %243 = OpLabel
+        %294 = OpPhi %int %int_0 %177 %265 %244
+        %249 = OpSLessThan %bool %294 %int_16
+               OpLoopMerge %245 %244 None
+               OpBranchConditional %249 %244 %245
+        %244 = OpLabel
+        %252 = OpAccessChain %_ptr_Input_v4float %in_interpolators %int_0 %294
+        %253 = OpLoad %v4float %252
+        %255 = OpAccessChain %_ptr_Input_v4float %in_interpolators %int_1 %294
+        %256 = OpLoad %v4float %255
+        %257 = OpFNegate %v4float %256
+        %258 = OpFAdd %v4float %253 %257
+        %260 = OpAccessChain %_ptr_Input_v4float %in_interpolators %int_2 %294
+        %261 = OpLoad %v4float %260
+        %262 = OpFAdd %v4float %258 %261
+        %263 = OpAccessChain %_ptr_Output_v4float %out_interpolators %294
+               OpStore %263 %262
+        %265 = OpIAdd %int %294 %int_1
+               OpBranch %243
+        %245 = OpLabel
+               OpEmitVertex
+               OpEndPrimitive
+               OpBranch %73
+         %73 = OpLabel
                OpReturn
                OpFunctionEnd
diff --git a/src/xenia/gpu/vulkan/shaders/rect_list.geom b/src/xenia/gpu/vulkan/shaders/rect_list.geom
index 5447b3391..515e1b576 100644
--- a/src/xenia/gpu/vulkan/shaders/rect_list.geom
+++ b/src/xenia/gpu/vulkan/shaders/rect_list.geom
@@ -28,10 +28,15 @@ layout(location = 16) out vec2 _out_point_coord_unused;
 
 layout(triangles) in;
 layout(triangle_strip, max_vertices = 6) out;
+
+bool equalsEpsilon(vec2 left, vec2 right, float epsilon) {
+  return all(lessThanEqual(abs(left - right), vec2(epsilon)));
+}
+
 void main() {
   // Most games use a left-aligned form.
-  if (gl_in[0].gl_Position.xy == vec2(gl_in[2].gl_Position.x, gl_in[1].gl_Position.y) ||
-      gl_in[0].gl_Position.xy == vec2(gl_in[1].gl_Position.x, gl_in[2].gl_Position.y)) {
+  if (equalsEpsilon(gl_in[0].gl_Position.xy, vec2(gl_in[2].gl_Position.x, gl_in[1].gl_Position.y), 0.001) ||
+      equalsEpsilon(gl_in[0].gl_Position.xy, vec2(gl_in[1].gl_Position.x, gl_in[2].gl_Position.y), 0.001)) {
     //  0 ------ 1   0:  -1,-1
     //  |      - |   1:   1,-1
     //  |   //   |   2:  -1, 1
diff --git a/src/xenia/gpu/vulkan/texture_config.cc b/src/xenia/gpu/vulkan/texture_config.cc
index 76afcc2d0..60098322c 100644
--- a/src/xenia/gpu/vulkan/texture_config.cc
+++ b/src/xenia/gpu/vulkan/texture_config.cc
@@ -99,7 +99,7 @@ const TextureConfig texture_configs[64] = {
     /* k_16_MPEG_INTERLACED        */ ___(UNDEFINED),
     /* k_16_16_MPEG_INTERLACED     */ ___(UNDEFINED),
 
-    // http://fileadmin.cs.lth.se/cs/Personal/Michael_Doggett/talks/unc-xenos-doggett.pdf
+    // https://fileadmin.cs.lth.se/cs/Personal/Michael_Doggett/talks/unc-xenos-doggett.pdf
     /* k_DXN                       */ ___(BC5_UNORM_BLOCK),  // ?
 
     /* k_8_8_8_8_AS_16_16_16_16    */ ___(R8G8B8A8_UNORM),
@@ -116,7 +116,7 @@ const TextureConfig texture_configs[64] = {
     /* k_DXT3A                     */ _c_(BC2_UNORM_BLOCK, ___R),
     /* k_DXT5A                     */ _c_(BC4_UNORM_BLOCK, RRRR),  // ATI1N
 
-    // http://fileadmin.cs.lth.se/cs/Personal/Michael_Doggett/talks/unc-xenos-doggett.pdf
+    // https://fileadmin.cs.lth.se/cs/Personal/Michael_Doggett/talks/unc-xenos-doggett.pdf
     /* k_CTX1                      */ ___(R8G8_UINT),
 
     /* k_DXT3A_AS_1_1_1_1          */ ___(UNDEFINED),
diff --git a/src/xenia/gpu/vulkan/vulkan_command_processor.cc b/src/xenia/gpu/vulkan/vulkan_command_processor.cc
index cf8ca2707..d5c786b37 100644
--- a/src/xenia/gpu/vulkan/vulkan_command_processor.cc
+++ b/src/xenia/gpu/vulkan/vulkan_command_processor.cc
@@ -916,7 +916,7 @@ bool VulkanCommandProcessor::IssueCopy() {
   assert_true(copy_regs->copy_mask == 0);
 
   // RB_SURFACE_INFO
-  // http://fossies.org/dox/MesaLib-10.3.5/fd2__gmem_8c_source.html
+  // https://fossies.org/dox/MesaLib-10.3.5/fd2__gmem_8c_source.html
   uint32_t surface_info = regs[XE_GPU_REG_RB_SURFACE_INFO].u32;
   uint32_t surface_pitch = surface_info & 0x3FFF;
   auto surface_msaa = static_cast<MsaaSamples>((surface_info >> 16) & 0x3);
diff --git a/src/xenia/gpu/xenos.h b/src/xenia/gpu/xenos.h
index b32b7ac71..88c3177e8 100644
--- a/src/xenia/gpu/xenos.h
+++ b/src/xenia/gpu/xenos.h
@@ -43,6 +43,16 @@ enum class PrimitiveType : uint32_t {
   k2DFillRectList = 0x14,
   k2DLineStrip = 0x15,
   k2DTriStrip = 0x16,
+  // Tessellation patches (D3DTPT) - reusing 2DCopyRectList types.
+  kLinePatch = 0x10,
+  kTrianglePatch = 0x11,
+  kQuadPatch = 0x12,
+};
+
+enum class TessellationMode : uint32_t {
+  kDiscrete = 0,
+  kContinuous = 1,
+  kAdaptive = 2,
 };
 
 enum class Dimension : uint32_t {
@@ -68,7 +78,7 @@ enum class TextureSign : uint32_t {
   kUnsigned = 0,
   // Two's complement texture data.
   kSigned = 1,
-  // 2*color-1 - http://xboxforums.create.msdn.com/forums/t/107374.aspx
+  // 2*color-1 - https://xboxforums.create.msdn.com/forums/t/107374.aspx
   kUnsignedBiased = 2,
   // Linearized when sampled.
   kGamma = 3,
@@ -146,6 +156,16 @@ enum class IndexFormat : uint32_t {
   kInt32,
 };
 
+// GPUSURFACENUMBER from a game .pdb. "Repeat" means repeating fraction, it's
+// what ATI calls normalized.
+enum class SurfaceNumFormat : uint32_t {
+  kUnsignedRepeat = 0,
+  kSignedRepeat = 1,
+  kUnsignedInteger = 2,
+  kSignedInteger = 3,
+  kFloat = 7,
+};
+
 enum class MsaaSamples : uint32_t {
   k1X = 0,
   k2X = 1,
@@ -168,7 +188,7 @@ enum class ColorRenderTargetFormat : uint32_t {
   k_16_16_16_16 = 5,
   k_16_16_FLOAT = 6,
   k_16_16_16_16_FLOAT = 7,
-  k_2_10_10_10_AS_16_16_16_16 = 10,
+  k_2_10_10_10_AS_10_10_10_10 = 10,
   k_2_10_10_10_FLOAT_AS_16_16_16_16 = 12,
   k_32_FLOAT = 14,
   k_32_32_FLOAT = 15,
@@ -567,6 +587,40 @@ XEPACKEDUNION(xe_gpu_fetch_group_t, {
   });
 });
 
+// GPU_MEMEXPORT_STREAM_CONSTANT from a game .pdb - float constant for memexport
+// stream configuration.
+// This is used with the floating-point ALU in shaders (written to eA using
+// mad), so the dwords have a normalized exponent when reinterpreted as floats
+// (otherwise they would be flushed to zero), but actually these are packed
+// integers. dword_1 specifically is 2^23 because
+// powf(2.0f, 23.0f) + float(i) == 0x4B000000 | i
+// so mad can pack indices as integers in the lower bits.
+XEPACKEDUNION(xe_gpu_memexport_stream_t, {
+  XEPACKEDSTRUCTANONYMOUS({
+    uint32_t base_address : 30;  // +0 dword_0 physical address >> 2
+    uint32_t const_0x1 : 2;      // +30
+
+    uint32_t const_0x4b000000;  // +0 dword_1
+
+    Endian128 endianness : 3;         // +0 dword_2
+    uint32_t unused_0 : 5;            // +3
+    ColorFormat format : 6;           // +8
+    uint32_t unused_1 : 2;            // +14
+    SurfaceNumFormat num_format : 3;  // +16
+    uint32_t red_blue_swap : 1;       // +19
+    uint32_t const_0x4b0 : 12;        // +20
+
+    uint32_t index_count : 23;  // +0 dword_3
+    uint32_t const_0x96 : 9;    // +23
+  });
+  XEPACKEDSTRUCTANONYMOUS({
+    uint32_t dword_0;
+    uint32_t dword_1;
+    uint32_t dword_2;
+    uint32_t dword_3;
+  });
+});
+
 // Enum of event values used for VGT_EVENT_INITIATOR
 enum Event {
   VS_DEALLOC = 0,
diff --git a/src/xenia/hid/input.h b/src/xenia/hid/input.h
index bf94fd451..a0f95c440 100644
--- a/src/xenia/hid/input.h
+++ b/src/xenia/hid/input.h
@@ -70,7 +70,7 @@ struct X_INPUT_CAPABILITIES {
 static_assert_size(X_INPUT_CAPABILITIES,
                    sizeof(X_INPUT_GAMEPAD) + sizeof(X_INPUT_VIBRATION) + 4);
 
-// http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinput_keystroke(v=vs.85).aspx
+// https://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinput_keystroke(v=vs.85).aspx
 struct X_INPUT_KEYSTROKE {
   be<uint16_t> virtual_key;
   be<uint16_t> unicode;
diff --git a/src/xenia/hid/xinput/xinput_input_driver.cc b/src/xenia/hid/xinput/xinput_input_driver.cc
index b0c748e20..9e6d2f90c 100644
--- a/src/xenia/hid/xinput/xinput_input_driver.cc
+++ b/src/xenia/hid/xinput/xinput_input_driver.cc
@@ -21,26 +21,64 @@ namespace hid {
 namespace xinput {
 
 XInputInputDriver::XInputInputDriver(xe::ui::Window* window)
-    : InputDriver(window) {
-#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8 && _WIN32_WINNT < _WIN32_WINNT_WIN10)
-  // TODO(gibbed): Is this necessary?
-  XInputEnable(TRUE);
-#endif
-}
+    : InputDriver(window),
+      module_(nullptr),
+      XInputGetCapabilities_(nullptr),
+      XInputGetState_(nullptr),
+      XInputGetKeystroke_(nullptr),
+      XInputSetState_(nullptr),
+      XInputEnable_(nullptr) {}
 
 XInputInputDriver::~XInputInputDriver() {
-#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8 && _WIN32_WINNT < _WIN32_WINNT_WIN10)
-  // TODO(gibbed): Is this necessary?
-  XInputEnable(FALSE);
-#endif
+  if (module_) {
+    FreeLibrary((HMODULE)module_);
+    module_ = nullptr;
+    XInputGetCapabilities_ = nullptr;
+    XInputGetState_ = nullptr;
+    XInputGetKeystroke_ = nullptr;
+    XInputSetState_ = nullptr;
+    XInputEnable_ = nullptr;
+  }
 }
 
-X_STATUS XInputInputDriver::Setup() { return X_STATUS_SUCCESS; }
+X_STATUS XInputInputDriver::Setup() {
+  HMODULE module = LoadLibraryW(L"xinput1_4.dll");
+  if (!module) {
+    module = LoadLibraryW(L"xinput1_3.dll");
+  }
+  if (!module) {
+    return X_STATUS_DLL_NOT_FOUND;
+  }
+
+  // Required.
+  auto xigc = GetProcAddress(module, "XInputGetCapabilities");
+  auto xigs = GetProcAddress(module, "XInputGetState");
+  auto xigk = GetProcAddress(module, "XInputGetKeystroke");
+  auto xiss = GetProcAddress(module, "XInputSetState");
+
+  // Not required.
+  auto xie = GetProcAddress(module, "XInputEnable");
+
+  // Only fail when we don't have the bare essentials;
+  if (!xigc || !xigs || !xigk || !xiss) {
+    FreeLibrary(module);
+    return X_STATUS_PROCEDURE_NOT_FOUND;
+  }
+
+  module_ = module;
+  XInputGetCapabilities_ = xigc;
+  XInputGetState_ = xigs;
+  XInputGetKeystroke_ = xigk;
+  XInputSetState_ = xiss;
+  XInputEnable_ = xie;
+  return X_STATUS_SUCCESS;
+}
 
 X_RESULT XInputInputDriver::GetCapabilities(uint32_t user_index, uint32_t flags,
                                             X_INPUT_CAPABILITIES* out_caps) {
   XINPUT_CAPABILITIES native_caps;
-  DWORD result = XInputGetCapabilities(user_index, flags, &native_caps);
+  auto xigc = (decltype(&XInputGetCapabilities))XInputGetCapabilities_;
+  DWORD result = xigc(user_index, flags, &native_caps);
   if (result) {
     return result;
   }
@@ -65,7 +103,8 @@ X_RESULT XInputInputDriver::GetCapabilities(uint32_t user_index, uint32_t flags,
 X_RESULT XInputInputDriver::GetState(uint32_t user_index,
                                      X_INPUT_STATE* out_state) {
   XINPUT_STATE native_state;
-  DWORD result = XInputGetState(user_index, &native_state);
+  auto xigs = (decltype(&XInputGetState))XInputGetState_;
+  DWORD result = xigs(user_index, &native_state);
   if (result) {
     return result;
   }
@@ -87,7 +126,8 @@ X_RESULT XInputInputDriver::SetState(uint32_t user_index,
   XINPUT_VIBRATION native_vibration;
   native_vibration.wLeftMotorSpeed = vibration->left_motor_speed;
   native_vibration.wRightMotorSpeed = vibration->right_motor_speed;
-  DWORD result = XInputSetState(user_index, &native_vibration);
+  auto xiss = (decltype(&XInputSetState))XInputSetState_;
+  DWORD result = xiss(user_index, &native_vibration);
   return result;
 }
 
@@ -99,18 +139,20 @@ X_RESULT XInputInputDriver::GetKeystroke(uint32_t user_index, uint32_t flags,
 
   // XInputGetKeystroke on Windows has a bug where it will return
   // ERROR_SUCCESS (0) even if the device is not connected:
-  // http://stackoverflow.com/questions/23669238/xinputgetkeystroke-returning-error-success-while-controller-is-unplugged
+  // https://stackoverflow.com/questions/23669238/xinputgetkeystroke-returning-error-success-while-controller-is-unplugged
   //
   // So we first check if the device is connected via XInputGetCapabilities, so
   // we are not passing back an uninitialized X_INPUT_KEYSTROKE structure:
   XINPUT_CAPABILITIES caps;
-  result = XInputGetCapabilities(user_index, 0, &caps);
+  auto xigc = (decltype(&XInputGetCapabilities))XInputGetCapabilities_;
+  result = xigc(user_index, 0, &caps);
   if (result) {
     return result;
   }
 
   XINPUT_KEYSTROKE native_keystroke;
-  result = XInputGetKeystroke(user_index, 0, &native_keystroke);
+  auto xigk = (decltype(&XInputGetKeystroke))XInputGetKeystroke_;
+  result = xigk(user_index, 0, &native_keystroke);
   if (result) {
     return result;
   }
diff --git a/src/xenia/hid/xinput/xinput_input_driver.h b/src/xenia/hid/xinput/xinput_input_driver.h
index fbf75c422..dcde26197 100644
--- a/src/xenia/hid/xinput/xinput_input_driver.h
+++ b/src/xenia/hid/xinput/xinput_input_driver.h
@@ -31,6 +31,12 @@ class XInputInputDriver : public InputDriver {
                         X_INPUT_KEYSTROKE* out_keystroke) override;
 
  protected:
+  void* module_;
+  void* XInputGetCapabilities_;
+  void* XInputGetState_;
+  void* XInputGetKeystroke_;
+  void* XInputSetState_;
+  void* XInputEnable_;
 };
 
 }  // namespace xinput
diff --git a/src/xenia/kernel/kernel_state.cc b/src/xenia/kernel/kernel_state.cc
index 5cb8be150..94a3beac5 100644
--- a/src/xenia/kernel/kernel_state.cc
+++ b/src/xenia/kernel/kernel_state.cc
@@ -31,8 +31,6 @@
 
 DEFINE_bool(headless, false,
             "Don't display any UI, using defaults for prompts as needed.");
-DEFINE_string(content_root, "content",
-              "Root path for content (save/etc) storage.");
 
 namespace xe {
 namespace kernel {
@@ -57,7 +55,7 @@ KernelState::KernelState(Emulator* emulator)
   app_manager_ = std::make_unique<xam::AppManager>();
   user_profile_ = std::make_unique<xam::UserProfile>();
 
-  auto content_root = xe::to_wstring(FLAGS_content_root);
+  auto content_root = emulator_->content_root();
   content_root = xe::to_absolute_path(content_root);
   content_manager_ = std::make_unique<xam::ContentManager>(this, content_root);
 
@@ -581,7 +579,7 @@ void KernelState::RegisterNotifyListener(NotifyListener* listener) {
 
   // Games seem to expect a few notifications on startup, only for the first
   // listener.
-  // http://cs.rin.ru/forum/viewtopic.php?f=38&t=60668&hilit=resident+evil+5&start=375
+  // https://cs.rin.ru/forum/viewtopic.php?f=38&t=60668&hilit=resident+evil+5&start=375
   if (!has_notified_startup_ && listener->mask() & 0x00000001) {
     has_notified_startup_ = true;
     // XN_SYS_UI (on, off)
diff --git a/src/xenia/kernel/user_module.cc b/src/xenia/kernel/user_module.cc
index d630ab669..18835d956 100644
--- a/src/xenia/kernel/user_module.cc
+++ b/src/xenia/kernel/user_module.cc
@@ -21,6 +21,8 @@
 #include "xenia/kernel/xthread.h"
 #include "xenia/vfs/devices/stfs_container_device.h"
 
+DEFINE_bool(xex_apply_patches, true, "Apply XEX patches.");
+
 namespace xe {
 namespace kernel {
 
@@ -103,8 +105,12 @@ X_STATUS UserModule::LoadFromFile(std::string path) {
     return result;
   }
 
+  if (!FLAGS_xex_apply_patches) {
+    return LoadXexContinue();
+  }
+  
   auto module_path = fs_entry->path();
-
+  
   auto content_manager = kernel_state()->content_manager();
 
   if (!file_system->IsSymbolicLink("update:")) {
@@ -143,7 +149,6 @@ X_STATUS UserModule::LoadFromFile(std::string path) {
   if (!patch_entry) {
     patch_entry = file_system->ResolvePath(path_ + "p");
   }
-
   if (patch_entry) {
     auto patch_path = patch_entry->absolute_path();
 
@@ -523,29 +528,32 @@ void UserModule::Dump() {
         std::memset(string_table, 0, sizeof(string_table));
 
         // Parse the string table
-        for (size_t l = 0, j = 0; l < opt_import_libraries->string_table_size;
-             j++) {
-          assert_true(j < xe::countof(string_table));
-          const char* str = opt_import_libraries->string_table + l;
+        for (size_t j = 0, o = 0; j < opt_import_libraries->string_table.size &&
+                                  o < opt_import_libraries->string_table.count;
+             o++) {
+          assert_true(o < xe::countof(string_table));
+          const char* str = &opt_import_libraries->string_table.data[j];
 
-          string_table[j] = str;
-          l += std::strlen(str) + 1;
+          string_table[o] = str;
+          j += std::strlen(str) + 1;
 
           // Padding
-          if ((l % 4) != 0) {
-            l += 4 - (l % 4);
+          if ((j % 4) != 0) {
+            j += 4 - (j % 4);
           }
         }
 
-        auto libraries =
-            reinterpret_cast<const uint8_t*>(opt_import_libraries) +
-            opt_import_libraries->string_table_size + 12;
-        uint32_t library_offset = 0;
-        uint32_t library_count = opt_import_libraries->library_count;
-        for (uint32_t l = 0; l < library_count; l++) {
+        auto library_data =
+            reinterpret_cast<const uint8_t*>(opt_import_libraries);
+        uint32_t library_offset = opt_import_libraries->string_table.size + 12;
+        while (library_offset < opt_import_libraries->size) {
           auto library = reinterpret_cast<const xex2_import_library*>(
-              libraries + library_offset);
+              library_data + library_offset);
+          if (!library->size) {
+            break;
+          }
           auto name = string_table[library->name_index & 0xFF];
+          assert_not_null(name);
           sb.AppendFormat("    %s - %d imports\n", name,
                           (uint16_t)library->count);
 
@@ -720,12 +728,13 @@ void UserModule::Dump() {
     const uint32_t page_size =
         xex_module()->base_address() < 0x90000000 ? 64 * 1024 : 4 * 1024;
     uint32_t start_address = xex_module()->base_address() + (page * page_size);
-    uint32_t end_address = start_address + (page_descriptor.size * page_size);
+    uint32_t end_address =
+        start_address + (page_descriptor.page_count * page_size);
 
     sb.AppendFormat("  %3u %s %3u pages    %.8X - %.8X (%d bytes)\n", page,
-                    type, page_descriptor.size, start_address, end_address,
-                    page_descriptor.size * page_size);
-    page += page_descriptor.size;
+                    type, page_descriptor.page_count, start_address,
+                    end_address, page_descriptor.page_count * page_size);
+    page += page_descriptor.page_count;
   }
 
   // Print out imports.
@@ -822,11 +831,11 @@ void UserModule::Dump() {
         }
         if (kernel_export &&
             kernel_export->type == cpu::Export::Type::kVariable) {
-          sb.AppendFormat("   V %.8X          %.3X (%3d) %s %s\n",
+          sb.AppendFormat("   V %.8X          %.3X (%4d) %s %s\n",
                           info->value_address, info->ordinal, info->ordinal,
                           implemented ? "  " : "!!", name);
         } else if (info->thunk_address) {
-          sb.AppendFormat("   F %.8X %.8X %.3X (%3d) %s %s\n",
+          sb.AppendFormat("   F %.8X %.8X %.3X (%4d) %s %s\n",
                           info->value_address, info->thunk_address,
                           info->ordinal, info->ordinal,
                           implemented ? "  " : "!!", name);
diff --git a/src/xenia/kernel/util/shim_utils.h b/src/xenia/kernel/util/shim_utils.h
index e478223ab..0809a660e 100644
--- a/src/xenia/kernel/util/shim_utils.h
+++ b/src/xenia/kernel/util/shim_utils.h
@@ -531,15 +531,43 @@ xe::cpu::Export* RegisterExport(void (*fn)(Ps&...), const char* name,
 
 using xe::cpu::ExportTag;
 
-#define DECLARE_EXPORT(module_name, name, tags)                            \
+#define DECLARE_EXPORT(module_name, name, category, tags)                  \
   const auto EXPORT_##module_name##_##name = RegisterExport_##module_name( \
       xe::kernel::shim::RegisterExport<                                    \
           xe::kernel::shim::KernelModuleId::module_name, ordinals::name>(  \
-          &name, #name, tags));
+          &name, #name,                                                    \
+          tags | (static_cast<xe::cpu::ExportTag::type>(                   \
+                      xe::cpu::ExportCategory::category)                   \
+                  << xe::cpu::ExportTag::CategoryShift)));
 
-#define DECLARE_XAM_EXPORT(name, tags) DECLARE_EXPORT(xam, name, tags)
-#define DECLARE_XBDM_EXPORT(name, tags) DECLARE_EXPORT(xbdm, name, tags)
-#define DECLARE_XBOXKRNL_EXPORT(name, tags) DECLARE_EXPORT(xboxkrnl, name, tags)
+#define DECLARE_XAM_EXPORT_(name, category, tags) \
+  DECLARE_EXPORT(xam, name, category, tags)
+#define DECLARE_XAM_EXPORT1(name, category, tag) \
+  DECLARE_EXPORT(xam, name, category, xe::cpu::ExportTag::tag)
+#define DECLARE_XAM_EXPORT2(name, category, tag1, tag2) \
+  DECLARE_EXPORT(xam, name, category,                   \
+                 xe::cpu::ExportTag::tag1 | xe::cpu::ExportTag::tag2)
+
+#define DECLARE_XBDM_EXPORT_(name, category, tags) \
+  DECLARE_EXPORT(xbdm, name, category, tags)
+#define DECLARE_XBDM_EXPORT1(name, category, tag) \
+  DECLARE_EXPORT(xbdm, name, category, xe::cpu::ExportTag::tag)
+
+#define DECLARE_XBOXKRNL_EXPORT_(name, category, tags) \
+  DECLARE_EXPORT(xboxkrnl, name, category, tags)
+#define DECLARE_XBOXKRNL_EXPORT1(name, category, tag) \
+  DECLARE_EXPORT(xboxkrnl, name, category, xe::cpu::ExportTag::tag)
+#define DECLARE_XBOXKRNL_EXPORT2(name, category, tag1, tag2) \
+  DECLARE_EXPORT(xboxkrnl, name, category,                   \
+                 xe::cpu::ExportTag::tag1 | xe::cpu::ExportTag::tag2)
+#define DECLARE_XBOXKRNL_EXPORT3(name, category, tag1, tag2, tag3)     \
+  DECLARE_EXPORT(xboxkrnl, name, category,                             \
+                 xe::cpu::ExportTag::tag1 | xe::cpu::ExportTag::tag2 | \
+                     xe::cpu::ExportTag::tag3)
+#define DECLARE_XBOXKRNL_EXPORT4(name, category, tag1, tag2, tag3, tag4) \
+  DECLARE_EXPORT(xboxkrnl, name, category,                               \
+                 xe::cpu::ExportTag::tag1 | xe::cpu::ExportTag::tag2 |   \
+                     xe::cpu::ExportTag::tag3 | xe::cpu::ExportTag::tag4)
 
 }  // namespace kernel
 }  // namespace xe
diff --git a/src/xenia/kernel/util/xdbf_utils.h b/src/xenia/kernel/util/xdbf_utils.h
index 36631cfc7..83ba12e27 100644
--- a/src/xenia/kernel/util/xdbf_utils.h
+++ b/src/xenia/kernel/util/xdbf_utils.h
@@ -19,8 +19,8 @@ namespace xe {
 namespace kernel {
 namespace util {
 
-// http://freestyledash.googlecode.com/svn/trunk/Freestyle/Tools/XEX/SPA.h
-// http://freestyledash.googlecode.com/svn/trunk/Freestyle/Tools/XEX/SPA.cpp
+// https://github.com/oukiar/freestyledash/blob/master/Freestyle/Tools/XEX/SPA.h
+// https://github.com/oukiar/freestyledash/blob/master/Freestyle/Tools/XEX/SPA.cpp
 
 enum class XdbfSection : uint16_t {
   kMetadata = 0x0001,
@@ -49,7 +49,7 @@ struct XdbfBlock {
 };
 
 // Wraps an XBDF (XboxDataBaseFormat) in-memory database.
-// http://www.free60.org/wiki/XDBF
+// https://free60project.github.io/wiki/XDBF.html
 class XdbfWrapper {
  public:
   XdbfWrapper(const uint8_t* data, size_t data_size);
diff --git a/src/xenia/kernel/util/xex2_info.h b/src/xenia/kernel/util/xex2_info.h
index 4a7d85d2f..f91b7c30f 100644
--- a/src/xenia/kernel/util/xex2_info.h
+++ b/src/xenia/kernel/util/xex2_info.h
@@ -474,10 +474,12 @@ struct xex2_opt_execution_info {
 static_assert_size(xex2_opt_execution_info, 0x18);
 
 struct xex2_opt_import_libraries {
-  xe::be<uint32_t> section_size;       // 0x0
-  xe::be<uint32_t> string_table_size;  // 0x4
-  xe::be<uint32_t> library_count;      // 0x8
-  char string_table[1];                // 0xC string_table_size bytes
+  xe::be<uint32_t> size;  // 0x0
+  struct {
+    xe::be<uint32_t> size;   // 0x4
+    xe::be<uint32_t> count;  // 0x8
+    char data[1];            // 0xC string_table_size bytes
+  } string_table;
 };
 
 struct xex2_import_library {
@@ -514,8 +516,8 @@ struct xex2_header {
 struct xex2_page_descriptor {
   union {
     struct {
-      uint32_t info : 4;
-      uint32_t size : 28;
+      xex2_section_type info : 4;
+      uint32_t page_count : 28;
     };
     xe::be<uint32_t> value;  // 0x0
   };
diff --git a/src/xenia/kernel/xam/app_manager.cc b/src/xenia/kernel/xam/app_manager.cc
index e83740776..fc18ca729 100644
--- a/src/xenia/kernel/xam/app_manager.cc
+++ b/src/xenia/kernel/xam/app_manager.cc
@@ -10,6 +10,7 @@
 #include "xenia/kernel/xam/app_manager.h"
 
 #include "xenia/kernel/kernel_state.h"
+#include "xenia/kernel/xam/apps/unknown_fe_app.h"
 #include "xenia/kernel/xam/apps/xgi_app.h"
 #include "xenia/kernel/xam/apps/xlivebase_app.h"
 #include "xenia/kernel/xam/apps/xmp_app.h"
@@ -24,9 +25,10 @@ App::App(KernelState* kernel_state, uint32_t app_id)
       app_id_(app_id) {}
 
 void AppManager::RegisterApps(KernelState* kernel_state, AppManager* manager) {
+  manager->RegisterApp(std::make_unique<apps::XmpApp>(kernel_state));
   manager->RegisterApp(std::make_unique<apps::XgiApp>(kernel_state));
   manager->RegisterApp(std::make_unique<apps::XLiveBaseApp>(kernel_state));
-  manager->RegisterApp(std::make_unique<apps::XmpApp>(kernel_state));
+  manager->RegisterApp(std::make_unique<apps::UnknownFEApp>(kernel_state));
 }
 
 void AppManager::RegisterApp(std::unique_ptr<App> app) {
diff --git a/src/xenia/kernel/xam/app_manager.h b/src/xenia/kernel/xam/app_manager.h
index 2420cdd6a..8a7655406 100644
--- a/src/xenia/kernel/xam/app_manager.h
+++ b/src/xenia/kernel/xam/app_manager.h
@@ -35,6 +35,8 @@ class App {
   virtual X_RESULT DispatchMessageSync(uint32_t message, uint32_t buffer_ptr,
                                        uint32_t buffer_length) = 0;
 
+  virtual ~App() = default;
+
  protected:
   App(KernelState* kernel_state, uint32_t app_id);
 
diff --git a/src/xenia/kernel/xam/apps/unknown_fe_app.cc b/src/xenia/kernel/xam/apps/unknown_fe_app.cc
new file mode 100644
index 000000000..cb05a339e
--- /dev/null
+++ b/src/xenia/kernel/xam/apps/unknown_fe_app.cc
@@ -0,0 +1,55 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2015 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include "xenia/kernel/xam/apps/unknown_fe_app.h"
+
+#include "xenia/base/logging.h"
+#include "xenia/base/threading.h"
+
+namespace xe {
+namespace kernel {
+namespace xam {
+namespace apps {
+
+UnknownFEApp::UnknownFEApp(KernelState* kernel_state)
+    : App(kernel_state, 0xFE) {}
+
+X_RESULT UnknownFEApp::DispatchMessageSync(uint32_t message,
+                                           uint32_t buffer_ptr,
+                                           uint32_t buffer_length) {
+  // NOTE: buffer_length may be zero or valid.
+  auto buffer = memory_->TranslateVirtual(buffer_ptr);
+  switch (message) {
+    case 0x00020021: {
+      struct message_data {
+        char unk_00[64];
+        xe::be<uint32_t> unk_40;  // KeGetCurrentProcessType() < 1 ? 1 : 0
+        xe::be<uint32_t> unk_44;  // ? output_ptr ?
+        xe::be<uint32_t> unk_48;  // ? overlapped_ptr ?
+      }* data = reinterpret_cast<message_data*>(buffer);
+      assert_true(buffer_length == sizeof(message_data));
+      auto unk = memory_->TranslateVirtual<xe::be<uint32_t>*>(data->unk_44);
+      *unk = 0;
+      XELOGD("UnknownFEApp(0x00020021)('%s', %.8X, %.8X, %.8X)", data->unk_00,
+             (uint32_t)data->unk_40, (uint32_t)data->unk_44,
+             (uint32_t)data->unk_48);
+      return X_ERROR_SUCCESS;
+    }
+  }
+  XELOGE(
+      "Unimplemented 0xFE message app=%.8X, msg=%.8X, arg1=%.8X, "
+      "arg2=%.8X",
+      app_id(), message, buffer_ptr, buffer_length);
+  return X_STATUS_UNSUCCESSFUL;
+}
+
+}  // namespace apps
+}  // namespace xam
+}  // namespace kernel
+}  // namespace xe
diff --git a/src/xenia/kernel/xam/apps/unknown_fe_app.h b/src/xenia/kernel/xam/apps/unknown_fe_app.h
new file mode 100644
index 000000000..f2d764f17
--- /dev/null
+++ b/src/xenia/kernel/xam/apps/unknown_fe_app.h
@@ -0,0 +1,34 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2015 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_KERNEL_XAM_APPS_UNKNOWN_FE_APP_H_
+#define XENIA_KERNEL_XAM_APPS_UNKNOWN_FE_APP_H_
+
+#include "xenia/kernel/kernel_state.h"
+#include "xenia/kernel/xam/app_manager.h"
+
+namespace xe {
+namespace kernel {
+namespace xam {
+namespace apps {
+
+class UnknownFEApp : public App {
+ public:
+  explicit UnknownFEApp(KernelState* kernel_state);
+
+  X_RESULT DispatchMessageSync(uint32_t message, uint32_t buffer_ptr,
+                               uint32_t buffer_length) override;
+};
+
+}  // namespace apps
+}  // namespace xam
+}  // namespace kernel
+}  // namespace xe
+
+#endif  // XENIA_KERNEL_XAM_APPS_UNKNOWN_FE_APP_H_
diff --git a/src/xenia/kernel/xam/apps/xlivebase_app.cc b/src/xenia/kernel/xam/apps/xlivebase_app.cc
index db0ae94fc..4d7a4fd8a 100644
--- a/src/xenia/kernel/xam/apps/xlivebase_app.cc
+++ b/src/xenia/kernel/xam/apps/xlivebase_app.cc
@@ -35,6 +35,12 @@ X_RESULT XLiveBaseApp::DispatchMessageSync(uint32_t message,
       xe::store_and_swap<uint32_t>(buffer + 0, 1);  // ?
       return X_ERROR_SUCCESS;
     }
+    case 0x00058006: {
+      assert_true(!buffer_length || buffer_length == 4);
+      XELOGD("XLiveBaseGetNatType(%.8X)", buffer_ptr);
+      xe::store_and_swap<uint32_t>(buffer + 0, 1);  // XONLINE_NAT_OPEN
+      return X_ERROR_SUCCESS;
+    }
     case 0x00058020: {
       // 0x00058004 is called right before this.
       // We should create a XamEnumerate-able empty list here, but I'm not
diff --git a/src/xenia/kernel/xam/apps/xmp_app.h b/src/xenia/kernel/xam/apps/xmp_app.h
index 868d39c66..751323909 100644
--- a/src/xenia/kernel/xam/apps/xmp_app.h
+++ b/src/xenia/kernel/xam/apps/xmp_app.h
@@ -25,7 +25,7 @@ namespace xam {
 namespace apps {
 
 // Only source of docs for a lot of these functions:
-// http://freestyledash.googlecode.com/svn-history/r1/trunk/Freestyle/Scenes/Media/Music/ScnMusic.cpp
+// https://github.com/oukiar/freestyledash/blob/master/Freestyle/Scenes/Media/Music/ScnMusic.cpp
 
 class XmpApp : public App {
  public:
diff --git a/src/xenia/kernel/xam/content_manager.cc b/src/xenia/kernel/xam/content_manager.cc
index 546c116cb..e09defeda 100644
--- a/src/xenia/kernel/xam/content_manager.cc
+++ b/src/xenia/kernel/xam/content_manager.cc
@@ -25,6 +25,8 @@ namespace xam {
 
 static const wchar_t* kThumbnailFileName = L"__thumbnail.png";
 
+static const wchar_t* kGameUserContentDirName = L"profile";
+
 static int content_device_id_ = 0;
 
 ContentPackage::ContentPackage(KernelState* kernel_state, std::string root_name,
@@ -262,6 +264,20 @@ X_RESULT ContentManager::DeleteContent(const XCONTENT_DATA& data) {
   }
 }
 
+std::wstring ContentManager::ResolveGameUserContentPath() {
+  wchar_t title_id[9] = L"00000000";
+  std::swprintf(title_id, 9, L"%.8X", kernel_state_->title_id());
+  auto user_name = xe::to_wstring(kernel_state_->user_profile()->name());
+
+  // Per-game per-profile data location:
+  // content_root/title_id/profile/user_name
+  auto package_root = xe::join_paths(
+      root_path_,
+      xe::join_paths(title_id,
+                     xe::join_paths(kGameUserContentDirName, user_name)));
+  return package_root + xe::kWPathSeparator;
+}
+
 }  // namespace xam
 }  // namespace kernel
 }  // namespace xe
diff --git a/src/xenia/kernel/xam/content_manager.h b/src/xenia/kernel/xam/content_manager.h
index bfedf9b44..a8c652644 100644
--- a/src/xenia/kernel/xam/content_manager.h
+++ b/src/xenia/kernel/xam/content_manager.h
@@ -84,6 +84,7 @@ class ContentManager {
   X_RESULT SetContentThumbnail(const XCONTENT_DATA& data,
                                std::vector<uint8_t> buffer);
   X_RESULT DeleteContent(const XCONTENT_DATA& data);
+  std::wstring ResolveGameUserContentPath();
 
   void SetTitleIdOverride(uint32_t title_id) { title_id_override_ = title_id; }
 
diff --git a/src/xenia/kernel/xam/user_profile.cc b/src/xenia/kernel/xam/user_profile.cc
index 9e555405d..6471b3d1e 100644
--- a/src/xenia/kernel/xam/user_profile.cc
+++ b/src/xenia/kernel/xam/user_profile.cc
@@ -7,6 +7,10 @@
  ******************************************************************************
  */
 
+#include <sstream>
+
+#include "xenia/kernel/kernel_state.h"
+#include "xenia/kernel/util/shim_utils.h"
 #include "xenia/kernel/xam/user_profile.h"
 
 namespace xe {
@@ -17,7 +21,7 @@ UserProfile::UserProfile() {
   xuid_ = 0xBABEBABEBABEBABE;
   name_ = "User";
 
-  // http://cs.rin.ru/forum/viewtopic.php?f=38&t=60668&hilit=gfwl+live&start=195
+  // https://cs.rin.ru/forum/viewtopic.php?f=38&t=60668&hilit=gfwl+live&start=195
   // https://github.com/arkem/py360/blob/master/py360/constants.py
   // XPROFILE_GAMER_YAXIS_INVERSION
   AddSetting(std::make_unique<Int32Setting>(0x10040002, 0));
@@ -87,6 +91,10 @@ void UserProfile::AddSetting(std::unique_ptr<Setting> setting) {
   Setting* previous_setting = setting.get();
   std::swap(settings_[setting->setting_id], previous_setting);
 
+  if (setting->is_set && setting->is_title_specific()) {
+    SaveSetting(setting.get());
+  }
+
   if (previous_setting) {
     // replace: swap out the old setting from the owning list
     for (auto vec_it = setting_list_.begin(); vec_it != setting_list_.end();
@@ -107,7 +115,58 @@ UserProfile::Setting* UserProfile::GetSetting(uint32_t setting_id) {
   if (it == settings_.end()) {
     return nullptr;
   }
-  return it->second;
+  UserProfile::Setting* setting = it->second;
+  if (setting->is_title_specific()) {
+    // If what we have loaded in memory isn't for the title that is running
+    // right now, then load it from disk.
+    if (kernel_state()->title_id() != setting->loaded_title_id) {
+      LoadSetting(setting);
+    }
+  }
+  return setting;
+}
+
+void UserProfile::LoadSetting(UserProfile::Setting* setting) {
+  if (setting->is_title_specific()) {
+    auto content_dir =
+        kernel_state()->content_manager()->ResolveGameUserContentPath();
+    auto setting_id = xe::format_string(L"%.8X", setting->setting_id);
+    auto file_path = xe::join_paths(content_dir, setting_id);
+    auto file = xe::filesystem::OpenFile(file_path, "rb");
+    if (file) {
+      fseek(file, 0, SEEK_END);
+      uint32_t input_file_size = static_cast<uint32_t>(ftell(file));
+      fseek(file, 0, SEEK_SET);
+
+      std::vector<uint8_t> serialized_data(input_file_size);
+      fread(serialized_data.data(), 1, serialized_data.size(), file);
+      fclose(file);
+      setting->Deserialize(serialized_data);
+      setting->loaded_title_id = kernel_state()->title_id();
+    }
+  } else {
+    // Unsupported for now.  Other settings aren't per-game and need to be
+    // stored some other way.
+    XELOGW("Attempting to load unsupported profile setting from disk");
+  }
+}
+
+void UserProfile::SaveSetting(UserProfile::Setting* setting) {
+  if (setting->is_title_specific()) {
+    auto serialized_setting = setting->Serialize();
+    auto content_dir =
+        kernel_state()->content_manager()->ResolveGameUserContentPath();
+    xe::filesystem::CreateFolder(content_dir);
+    auto setting_id = xe::format_string(L"%.8X", setting->setting_id);
+    auto file_path = xe::join_paths(content_dir, setting_id);
+    auto file = xe::filesystem::OpenFile(file_path, "wb");
+    fwrite(serialized_setting.data(), 1, serialized_setting.size(), file);
+    fclose(file);
+  } else {
+    // Unsupported for now.  Other settings aren't per-game and need to be
+    // stored some other way.
+    XELOGW("Attempting to save unsupported profile setting to disk");
+  }
 }
 
 }  // namespace xam
diff --git a/src/xenia/kernel/xam/user_profile.h b/src/xenia/kernel/xam/user_profile.h
index 0afe2db8c..f8f2dacd8 100644
--- a/src/xenia/kernel/xam/user_profile.h
+++ b/src/xenia/kernel/xam/user_profile.h
@@ -25,7 +25,7 @@ class UserProfile {
  public:
   struct Setting {
     enum class Type {
-      UNKNOWN = 0,
+      CONTENT = 0,
       INT32 = 1,
       INT64 = 2,
       DOUBLE = 3,
@@ -48,8 +48,13 @@ class UserProfile {
     Type type;
     size_t size;
     bool is_set;
+    uint32_t loaded_title_id;
     Setting(uint32_t setting_id, Type type, size_t size, bool is_set)
-        : setting_id(setting_id), type(type), size(size), is_set(is_set) {}
+        : setting_id(setting_id),
+          type(type),
+          size(size),
+          is_set(is_set),
+          loaded_title_id(0) {}
     virtual size_t extra_size() const { return 0; }
     virtual size_t Append(uint8_t* user_data, uint8_t* buffer,
                           uint32_t buffer_ptr, size_t buffer_offset) {
@@ -57,6 +62,10 @@ class UserProfile {
                                   static_cast<uint8_t>(type));
       return buffer_offset;
     }
+    virtual std::vector<uint8_t> Serialize() const {
+      return std::vector<uint8_t>();
+    }
+    virtual void Deserialize(std::vector<uint8_t>) {}
     bool is_title_specific() const { return (setting_id & 0x3F00) == 0x3F00; }
 
    protected:
@@ -167,6 +176,13 @@ class UserProfile {
       }
       return buffer_offset + length;
     }
+    std::vector<uint8_t> Serialize() const override {
+      return std::vector<uint8_t>(value.data(), value.data() + value.size());
+    }
+    void Deserialize(std::vector<uint8_t> data) override {
+      value = data;
+      is_set = true;
+    }
   };
   struct DateTimeSetting : public Setting {
     DateTimeSetting(uint32_t setting_id, int64_t value)
@@ -195,6 +211,9 @@ class UserProfile {
   std::string name_;
   std::vector<std::unique_ptr<Setting>> setting_list_;
   std::unordered_map<uint32_t, Setting*> settings_;
+
+  void LoadSetting(UserProfile::Setting*);
+  void SaveSetting(UserProfile::Setting*);
 };
 
 }  // namespace xam
diff --git a/src/xenia/kernel/xam/xam_avatar.cc b/src/xenia/kernel/xam/xam_avatar.cc
index 3c2049b38..a949e91b2 100644
--- a/src/xenia/kernel/xam/xam_avatar.cc
+++ b/src/xenia/kernel/xam/xam_avatar.cc
@@ -28,12 +28,12 @@ dword_result_t XamAvatarInitialize(
   // Negative to fail. Game should immediately call XamAvatarShutdown.
   return ~0u;
 }
-DECLARE_XAM_EXPORT(XamAvatarInitialize, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamAvatarInitialize, kAvatars, kStub);
 
 void XamAvatarShutdown() {
   // No-op.
 }
-DECLARE_XAM_EXPORT(XamAvatarShutdown, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamAvatarShutdown, kAvatars, kStub);
 
 void RegisterAvatarExports(xe::cpu::ExportResolver* export_resolver,
                            KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xam/xam_content.cc b/src/xenia/kernel/xam/xam_content.cc
index 8cfc54a59..61e4ecdd2 100644
--- a/src/xenia/kernel/xam/xam_content.cc
+++ b/src/xenia/kernel/xam/xam_content.cc
@@ -23,142 +23,132 @@ struct DeviceInfo {
   uint32_t device_type;
   uint64_t total_bytes;
   uint64_t free_bytes;
-  std::wstring name;
+  wchar_t name[28];
 };
+
+// TODO(gibbed): real information.
+//
+// Until we expose real information about a HDD device, we
+// claim there is 3GB free on a 4GB dummy HDD.
+//
+// There is a possibility that certain games are bugged in that
+// they incorrectly only look at the lower 32-bits of free_bytes,
+// when it is a 64-bit value. Which means any size above ~4GB
+// will not be recognized properly.
+#define ONE_GB (1024ull * 1024ull * 1024ull)
 static const DeviceInfo dummy_device_info_ = {
-    0xF00D0000,
-    1,
-    120ull * 1024ull * 1024ull * 1024ull,  // 120GB
-    100ull * 1024ull * 1024ull * 1024ull,  // 100GB, so it looks a little used.
+    0xF00D0000,    1,
+    4ull * ONE_GB,  // 4GB
+    3ull * ONE_GB,  // 3GB, so it looks a little used.
     L"Dummy HDD",
 };
+#undef ONE_GB
 
-SHIM_CALL XamContentGetLicenseMask_shim(PPCContext* ppc_context,
-                                        KernelState* kernel_state) {
-  uint32_t mask_ptr = SHIM_GET_ARG_32(0);
-  uint32_t overlapped_ptr = SHIM_GET_ARG_32(1);
-
-  XELOGD("XamContentGetLicenseMask(%.8X, %.8X)", mask_ptr, overlapped_ptr);
-
+dword_result_t XamContentGetLicenseMask(lpdword_t mask_ptr,
+                                        lpunknown_t overlapped_ptr) {
   // Each bit in the mask represents a granted license. Available licenses
   // seems to vary from game to game, but most appear to use bit 0 to indicate
   // if the game is purchased or not.
-  SHIM_SET_MEM_32(mask_ptr, 0);
+  *mask_ptr = 0;
 
   if (overlapped_ptr) {
-    kernel_state->CompleteOverlappedImmediate(overlapped_ptr, X_ERROR_SUCCESS);
-    SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
+    kernel_state()->CompleteOverlappedImmediate(overlapped_ptr,
+                                                X_ERROR_SUCCESS);
+    return X_ERROR_IO_PENDING;
   } else {
-    SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
+    return X_ERROR_SUCCESS;
   }
 }
+DECLARE_XAM_EXPORT2(XamContentGetLicenseMask, kContent, kStub, kHighFrequency);
 
-SHIM_CALL XamContentGetDeviceName_shim(PPCContext* ppc_context,
-                                       KernelState* kernel_state) {
-  uint32_t device_id = SHIM_GET_ARG_32(0);
-  uint32_t name_ptr = SHIM_GET_ARG_32(1);
-  uint32_t name_capacity = SHIM_GET_ARG_32(2);
-
-  XELOGD("XamContentGetDeviceName(%.8X, %.8X, %d)", device_id, name_ptr,
-         name_capacity);
-
+dword_result_t XamContentGetDeviceName(dword_t device_id,
+                                       lpwstring_t name_buffer,
+                                       dword_t name_capacity) {
   if ((device_id & 0xFFFF0000) != dummy_device_info_.device_id) {
-    SHIM_SET_RETURN_32(X_ERROR_DEVICE_NOT_CONNECTED);
-    return;
+    return X_ERROR_DEVICE_NOT_CONNECTED;
   }
 
-  if (name_capacity < dummy_device_info_.name.size() + 1) {
-    SHIM_SET_RETURN_32(X_ERROR_INSUFFICIENT_BUFFER);
-    return;
+  auto name = std::wstring(dummy_device_info_.name);
+  if (name_capacity < name.size() + 1) {
+    return X_ERROR_INSUFFICIENT_BUFFER;
   }
 
-  xe::store_and_swap<std::wstring>(SHIM_MEM_ADDR(name_ptr),
-                                   dummy_device_info_.name);
-
-  SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
+  xe::store_and_swap<std::wstring>(name_buffer, name);
+  ((wchar_t*)name_buffer)[name.size()] = 0;
+  return X_ERROR_SUCCESS;
 }
+DECLARE_XAM_EXPORT1(XamContentGetDeviceName, kContent, kImplemented);
 
-SHIM_CALL XamContentGetDeviceState_shim(PPCContext* ppc_context,
-                                        KernelState* kernel_state) {
-  uint32_t device_id = SHIM_GET_ARG_32(0);
-  uint32_t overlapped_ptr = SHIM_GET_ARG_32(1);
-
-  XELOGD("XamContentGetDeviceState(%.8X, %.8X)", device_id, overlapped_ptr);
-
+dword_result_t XamContentGetDeviceState(dword_t device_id,
+                                        lpunknown_t overlapped_ptr) {
   if ((device_id & 0xFFFF0000) != dummy_device_info_.device_id) {
     if (overlapped_ptr) {
-      kernel_state->CompleteOverlappedImmediateEx(
+      kernel_state()->CompleteOverlappedImmediateEx(
           overlapped_ptr, X_ERROR_FUNCTION_FAILED, X_ERROR_DEVICE_NOT_CONNECTED,
           0);
-      SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
+      return X_ERROR_IO_PENDING;
     } else {
-      SHIM_SET_RETURN_32(X_ERROR_DEVICE_NOT_CONNECTED);
+      return X_ERROR_DEVICE_NOT_CONNECTED;
     }
-    return;
   }
 
   if (overlapped_ptr) {
-    kernel_state->CompleteOverlappedImmediate(overlapped_ptr, X_ERROR_SUCCESS);
-    SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
+    kernel_state()->CompleteOverlappedImmediate(overlapped_ptr,
+                                                X_ERROR_SUCCESS);
+    return X_ERROR_IO_PENDING;
   } else {
-    SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
+    return X_ERROR_SUCCESS;
   }
 }
+DECLARE_XAM_EXPORT1(XamContentGetDeviceState, kContent, kStub);
 
-SHIM_CALL XamContentGetDeviceData_shim(PPCContext* ppc_context,
-                                       KernelState* kernel_state) {
-  uint32_t device_id = SHIM_GET_ARG_32(0);
-  uint32_t device_data_ptr = SHIM_GET_ARG_32(1);
-
-  XELOGD("XamContentGetDeviceData(%.8X, %.8X)", device_id, device_data_ptr);
+typedef struct {
+  xe::be<uint32_t> device_id;
+  xe::be<uint32_t> unknown;
+  xe::be<uint64_t> total_bytes;
+  xe::be<uint64_t> free_bytes;
+  xe::be<uint16_t> name[28];
+} X_CONTENT_DEVICE_DATA;
+static_assert_size(X_CONTENT_DEVICE_DATA, 0x50);
 
+dword_result_t XamContentGetDeviceData(
+    dword_t device_id, pointer_t<X_CONTENT_DEVICE_DATA> device_data) {
   if ((device_id & 0xFFFF0000) != dummy_device_info_.device_id) {
     // TODO(benvanik): memset 0 the data?
-    SHIM_SET_RETURN_32(X_ERROR_DEVICE_NOT_CONNECTED);
-    return;
+    return X_ERROR_DEVICE_NOT_CONNECTED;
   }
 
+  device_data.Zero();
   const auto& device_info = dummy_device_info_;
-  SHIM_SET_MEM_32(device_data_ptr + 0, device_info.device_id);
-  SHIM_SET_MEM_32(device_data_ptr + 4, device_id & 0xFFFF);  // Fake it.
-  SHIM_SET_MEM_64(device_data_ptr + 8, device_info.total_bytes);
-  SHIM_SET_MEM_64(device_data_ptr + 16, device_info.free_bytes);
-  xe::store_and_swap<std::wstring>(SHIM_MEM_ADDR(device_data_ptr + 24),
-                                   device_info.name);
-
-  SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
+  device_data->device_id = device_info.device_id;
+  device_data->unknown = device_id & 0xFFFF;  // Fake it.
+  device_data->total_bytes = device_info.total_bytes;
+  device_data->free_bytes = device_info.free_bytes;
+  xe::store_and_swap<std::wstring>(&device_data->name[0], device_info.name);
+  return X_ERROR_SUCCESS;
 }
+DECLARE_XAM_EXPORT1(XamContentGetDeviceData, kContent, kImplemented);
 
-SHIM_CALL XamContentResolve_shim(PPCContext* ppc_context,
-                                 KernelState* kernel_state) {
-  uint32_t user_index = SHIM_GET_ARG_32(0);
-  uint32_t content_data_ptr = SHIM_GET_ARG_32(1);
-  uint32_t buffer_ptr = SHIM_GET_ARG_32(2);
-  uint32_t buffer_size = SHIM_GET_ARG_32(3);
-  uint32_t unk1 = SHIM_GET_ARG_32(4);  // 1
-  uint32_t unk2 = SHIM_GET_ARG_32(5);  // 0
-  uint32_t unk3 = SHIM_GET_ARG_32(6);  // 0
-
-  auto content_data = XCONTENT_DATA(SHIM_MEM_ADDR(content_data_ptr));
-
-  XELOGD("XamContentResolve(%d, %.8X, %.8X, %d, %.8X, %.8X, %.8X)", user_index,
-         content_data_ptr, buffer_ptr, buffer_size, unk1, unk2, unk3);
+dword_result_t XamContentResolve(dword_t user_index, lpvoid_t content_data_ptr,
+                                 lpunknown_t buffer_ptr, dword_t buffer_size,
+                                 dword_t unk1, dword_t unk2, dword_t unk3) {
+  auto content_data = XCONTENT_DATA((uint8_t*)content_data_ptr);
 
   // Result of buffer_ptr is sent to RtlInitAnsiString.
   // buffer_size is usually 260 (max path).
   // Games expect zero if resolve was successful.
   assert_always();
   XELOGW("XamContentResolve unimplemented!");
-
-  SHIM_SET_RETURN_32(X_ERROR_NOT_FOUND);
+  return X_ERROR_NOT_FOUND;
 }
+DECLARE_XAM_EXPORT1(XamContentResolve, kContent, kStub);
 
-// http://gameservice.googlecode.com/svn-history/r14/trunk/ContentManager.cpp
+// https://github.com/MrColdbird/gameservice/blob/master/ContentManager.cpp
 // https://github.com/LestaD/SourceEngine2007/blob/master/se2007/engine/xboxsystem.cpp#L499
 dword_result_t XamContentCreateEnumerator(dword_t user_index, dword_t device_id,
                                           dword_t content_type,
                                           dword_t content_flags,
-                                          dword_t max_count,
+                                          dword_t items_per_enumerate,
                                           lpdword_t buffer_size_ptr,
                                           lpdword_t handle_out) {
   assert_not_null(handle_out);
@@ -173,11 +163,11 @@ dword_result_t XamContentCreateEnumerator(dword_t user_index, dword_t device_id,
   }
 
   if (buffer_size_ptr) {
-    *buffer_size_ptr = (uint32_t)XCONTENT_DATA::kSize * max_count;
+    *buffer_size_ptr = (uint32_t)XCONTENT_DATA::kSize * items_per_enumerate;
   }
 
-  auto e =
-      new XStaticEnumerator(kernel_state(), max_count, XCONTENT_DATA::kSize);
+  auto e = new XStaticEnumerator(kernel_state(), items_per_enumerate,
+                                 XCONTENT_DATA::kSize);
   e->Initialize();
 
   // Get all content data.
@@ -187,18 +177,46 @@ dword_result_t XamContentCreateEnumerator(dword_t user_index, dword_t device_id,
       content_type);
   for (auto& content_data : content_datas) {
     auto ptr = e->AppendItem();
-    if (!ptr) {
-      // Too many items.
-      break;
-    }
-
+    assert_not_null(ptr);
     content_data.Write(ptr);
   }
 
+  XELOGD("XamContentCreateEnumerator: added %d items to enumerator",
+         e->item_count());
+
+  *handle_out = e->handle();
+  return X_ERROR_SUCCESS;
+}
+DECLARE_XAM_EXPORT1(XamContentCreateEnumerator, kContent, kImplemented);
+
+dword_result_t XamContentCreateDeviceEnumerator(dword_t content_type,
+                                                dword_t content_flags,
+                                                dword_t max_count,
+                                                lpdword_t buffer_size_ptr,
+                                                lpdword_t handle_out) {
+  assert_not_null(handle_out);
+
+  if (buffer_size_ptr) {
+    *buffer_size_ptr = sizeof(DeviceInfo) * max_count;
+  }
+
+  auto e = new XStaticEnumerator(kernel_state(), max_count, sizeof(DeviceInfo));
+  e->Initialize();
+
+  // Copy our dummy device into the enumerator
+  DeviceInfo* dev = (DeviceInfo*)e->AppendItem();
+  if (dev) {
+    xe::store_and_swap(&dev->device_id, dummy_device_info_.device_id);
+    xe::store_and_swap(&dev->device_type, dummy_device_info_.device_type);
+    xe::store_and_swap(&dev->total_bytes, dummy_device_info_.total_bytes);
+    xe::store_and_swap(&dev->free_bytes, dummy_device_info_.free_bytes);
+    xe::copy_and_swap(dev->name, dummy_device_info_.name, 28);
+  }
+
   *handle_out = e->handle();
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamContentCreateEnumerator, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamContentCreateDeviceEnumerator, kNone, kImplemented);
 
 dword_result_t XamContentCreateEx(dword_t user_index, lpstring_t root_name,
                                   lpvoid_t content_data_ptr, dword_t flags,
@@ -206,8 +224,6 @@ dword_result_t XamContentCreateEx(dword_t user_index, lpstring_t root_name,
                                   lpdword_t license_mask_ptr,
                                   dword_t cache_size, qword_t content_size,
                                   lpvoid_t overlapped_ptr) {
-  assert_null(license_mask_ptr);
-
   X_RESULT result = X_ERROR_INVALID_PARAMETER;
   auto content_data = XCONTENT_DATA((uint8_t*)content_data_ptr);
 
@@ -282,6 +298,10 @@ dword_result_t XamContentCreateEx(dword_t user_index, lpstring_t root_name,
     result = content_manager->OpenContent(root_name.value(), content_data);
   }
 
+  if (license_mask_ptr && XSUCCEEDED(result)) {
+    *license_mask_ptr = 0;  // Stub!
+  }
+
   if (overlapped_ptr) {
     kernel_state()->CompleteOverlappedImmediateEx(overlapped_ptr, result, 0,
                                                   disposition);
@@ -290,7 +310,7 @@ dword_result_t XamContentCreateEx(dword_t user_index, lpstring_t root_name,
     return result;
   }
 }
-DECLARE_XAM_EXPORT(XamContentCreateEx, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamContentCreateEx, kContent, kImplemented);
 
 dword_result_t XamContentCreate(dword_t user_index, lpstring_t root_name,
                                 lpvoid_t content_data_ptr, dword_t flags,
@@ -301,113 +321,91 @@ dword_result_t XamContentCreate(dword_t user_index, lpstring_t root_name,
                             disposition_ptr, license_mask_ptr, 0, 0,
                             overlapped_ptr);
 }
-DECLARE_XAM_EXPORT(XamContentCreate, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamContentCreate, kContent, kImplemented);
 
-dword_result_t XamContentOpenFile(dword_t r3, lpstring_t r4, lpstring_t r5,
-                                  dword_t r6, dword_t r7, dword_t r8,
-                                  dword_t r9) {
+dword_result_t XamContentOpenFile(dword_t user_index, lpstring_t root_name,
+                                  lpstring_t path, dword_t flags,
+                                  lpdword_t disposition_ptr,
+                                  lpdword_t license_mask_ptr,
+                                  lpvoid_t overlapped_ptr) {
+  // TODO(gibbed): arguments assumed based on XamContentCreate.
   return X_ERROR_FILE_NOT_FOUND;
 }
-DECLARE_XAM_EXPORT(XamContentOpenFile, ExportTag::kStub);
-
-SHIM_CALL XamContentFlush_shim(PPCContext* ppc_context,
-                               KernelState* kernel_state) {
-  uint32_t root_name_ptr = SHIM_GET_ARG_32(0);
-  uint32_t overlapped_ptr = SHIM_GET_ARG_32(1);
-
-  auto root_name = xe::load_and_swap<std::string>(SHIM_MEM_ADDR(root_name_ptr));
-
-  XELOGD("XamContentFlush(%.8X(%s), %.8X)", root_name_ptr, root_name.c_str(),
-         overlapped_ptr);
+DECLARE_XAM_EXPORT1(XamContentOpenFile, kContent, kStub);
 
+dword_result_t XamContentFlush(lpstring_t root_name,
+                               lpunknown_t overlapped_ptr) {
   X_RESULT result = X_ERROR_SUCCESS;
   if (overlapped_ptr) {
-    kernel_state->CompleteOverlappedImmediate(overlapped_ptr, result);
-    SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
+    kernel_state()->CompleteOverlappedImmediate(overlapped_ptr, result);
+    return X_ERROR_IO_PENDING;
   } else {
-    SHIM_SET_RETURN_32(result);
+    return result;
   }
 }
+DECLARE_XAM_EXPORT1(XamContentFlush, kContent, kStub);
 
-SHIM_CALL XamContentClose_shim(PPCContext* ppc_context,
-                               KernelState* kernel_state) {
-  uint32_t root_name_ptr = SHIM_GET_ARG_32(0);
-  uint32_t overlapped_ptr = SHIM_GET_ARG_32(1);
-
-  auto root_name = xe::load_and_swap<std::string>(SHIM_MEM_ADDR(root_name_ptr));
-
-  XELOGD("XamContentClose(%.8X(%s), %.8X)", root_name_ptr, root_name.c_str(),
-         overlapped_ptr);
-
+dword_result_t XamContentClose(lpstring_t root_name,
+                               lpunknown_t overlapped_ptr) {
   // Closes a previously opened root from XamContentCreate*.
-  auto result = kernel_state->content_manager()->CloseContent(root_name);
+  auto result =
+      kernel_state()->content_manager()->CloseContent(root_name.value());
 
   if (overlapped_ptr) {
-    kernel_state->CompleteOverlappedImmediate(overlapped_ptr, result);
-    SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
+    kernel_state()->CompleteOverlappedImmediate(overlapped_ptr, result);
+    return X_ERROR_IO_PENDING;
   } else {
-    SHIM_SET_RETURN_32(result);
+    return result;
   }
 }
+DECLARE_XAM_EXPORT1(XamContentClose, kContent, kImplemented);
 
-SHIM_CALL XamContentGetCreator_shim(PPCContext* ppc_context,
-                                    KernelState* kernel_state) {
-  uint32_t user_index = SHIM_GET_ARG_32(0);
-  uint32_t content_data_ptr = SHIM_GET_ARG_32(1);
-  uint32_t is_creator_ptr = SHIM_GET_ARG_32(2);
-  uint32_t creator_xuid_ptr = SHIM_GET_ARG_32(3);
-  uint32_t overlapped_ptr = SHIM_GET_ARG_32(4);
-
-  auto content_data = XCONTENT_DATA(SHIM_MEM_ADDR(content_data_ptr));
-
-  XELOGD("XamContentGetCreator(%d, %.8X, %.8X, %.8X, %.8X)", user_index,
-         content_data_ptr, is_creator_ptr, creator_xuid_ptr, overlapped_ptr);
-
+dword_result_t XamContentGetCreator(dword_t user_index,
+                                    lpvoid_t content_data_ptr,
+                                    lpdword_t is_creator_ptr,
+                                    lpqword_t creator_xuid_ptr,
+                                    lpunknown_t overlapped_ptr) {
   auto result = X_ERROR_SUCCESS;
 
+  auto content_data = XCONTENT_DATA((uint8_t*)content_data_ptr);
+
   if (content_data.content_type == 1) {
     // User always creates saves.
-    SHIM_SET_MEM_32(is_creator_ptr, 1);
+    *is_creator_ptr = 1;
     if (creator_xuid_ptr) {
-      SHIM_SET_MEM_64(creator_xuid_ptr, kernel_state->user_profile()->xuid());
+      *creator_xuid_ptr = kernel_state()->user_profile()->xuid();
     }
   } else {
-    SHIM_SET_MEM_32(is_creator_ptr, 0);
+    *is_creator_ptr = 0;
     if (creator_xuid_ptr) {
-      SHIM_SET_MEM_64(creator_xuid_ptr, 0);
+      *creator_xuid_ptr = 0;
     }
   }
 
   if (overlapped_ptr) {
-    kernel_state->CompleteOverlappedImmediate(overlapped_ptr, result);
-    SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
+    kernel_state()->CompleteOverlappedImmediate(overlapped_ptr, result);
+    return X_ERROR_IO_PENDING;
   } else {
-    SHIM_SET_RETURN_32(result);
+    return result;
   }
 }
+DECLARE_XAM_EXPORT1(XamContentGetCreator, kContent, kImplemented);
 
-SHIM_CALL XamContentGetThumbnail_shim(PPCContext* ppc_context,
-                                      KernelState* kernel_state) {
-  uint32_t user_index = SHIM_GET_ARG_32(0);
-  uint32_t content_data_ptr = SHIM_GET_ARG_32(1);
-  uint32_t buffer_ptr = SHIM_GET_ARG_32(2);
-  uint32_t buffer_size_ptr = SHIM_GET_ARG_32(3);
-  uint32_t overlapped_ptr = SHIM_GET_ARG_32(4);
-
-  assert_not_zero(buffer_size_ptr);
-  uint32_t buffer_size = SHIM_MEM_32(buffer_size_ptr);
-  auto content_data = XCONTENT_DATA(SHIM_MEM_ADDR(content_data_ptr));
-
-  XELOGD("XamContentGetThumbnail(%d, %.8X, %.8X, %.8X(%d), %.8X)", user_index,
-         content_data_ptr, buffer_ptr, buffer_size_ptr, buffer_size,
-         overlapped_ptr);
+dword_result_t XamContentGetThumbnail(dword_t user_index,
+                                      lpvoid_t content_data_ptr,
+                                      lpvoid_t buffer_ptr,
+                                      lpdword_t buffer_size_ptr,
+                                      lpunknown_t overlapped_ptr) {
+  assert_not_null(buffer_size_ptr);
+  uint32_t buffer_size = *buffer_size_ptr;
+  auto content_data = XCONTENT_DATA((uint8_t*)content_data_ptr);
 
   // Get thumbnail (if it exists).
   std::vector<uint8_t> buffer;
-  auto result = kernel_state->content_manager()->GetContentThumbnail(
+  auto result = kernel_state()->content_manager()->GetContentThumbnail(
       content_data, &buffer);
 
-  SHIM_SET_MEM_32(buffer_size_ptr, uint32_t(buffer.size()));
+  *buffer_size_ptr = uint32_t(buffer.size());
 
   if (XSUCCEEDED(result)) {
     // Write data, if we were given a pointer.
@@ -418,81 +416,58 @@ SHIM_CALL XamContentGetThumbnail_shim(PPCContext* ppc_context,
         result = X_ERROR_INSUFFICIENT_BUFFER;
       } else {
         // Copy data.
-        std::memcpy(SHIM_MEM_ADDR(buffer_ptr), buffer.data(), buffer.size());
+        std::memcpy((uint8_t*)buffer_ptr, buffer.data(), buffer.size());
       }
     }
   }
 
   if (overlapped_ptr) {
-    kernel_state->CompleteOverlappedImmediate(overlapped_ptr, result);
-    SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
+    kernel_state()->CompleteOverlappedImmediate(overlapped_ptr, result);
+    return X_ERROR_IO_PENDING;
   } else {
-    SHIM_SET_RETURN_32(result);
+    return result;
   }
 }
+DECLARE_XAM_EXPORT1(XamContentGetThumbnail, kContent, kImplemented);
 
-SHIM_CALL XamContentSetThumbnail_shim(PPCContext* ppc_context,
-                                      KernelState* kernel_state) {
-  uint32_t user_index = SHIM_GET_ARG_32(0);
-  uint32_t content_data_ptr = SHIM_GET_ARG_32(1);
-  uint32_t buffer_ptr = SHIM_GET_ARG_32(2);
-  uint32_t buffer_size = SHIM_GET_ARG_32(3);
-  uint32_t overlapped_ptr = SHIM_GET_ARG_32(4);
-
-  auto content_data = XCONTENT_DATA(SHIM_MEM_ADDR(content_data_ptr));
-
-  XELOGD("XamContentSetThumbnail(%d, %.8X, %.8X, %d, %.8X)", user_index,
-         content_data_ptr, buffer_ptr, buffer_size, overlapped_ptr);
+dword_result_t XamContentSetThumbnail(dword_t user_index,
+                                      lpvoid_t content_data_ptr,
+                                      lpvoid_t buffer_ptr, dword_t buffer_size,
+                                      lpunknown_t overlapped_ptr) {
+  auto content_data = XCONTENT_DATA((uint8_t*)content_data_ptr);
 
   // Buffer is PNG data.
-  auto buffer = std::vector<uint8_t>(SHIM_MEM_ADDR(buffer_ptr),
-                                     SHIM_MEM_ADDR(buffer_ptr) + buffer_size);
-  auto result = kernel_state->content_manager()->SetContentThumbnail(
+  auto buffer = std::vector<uint8_t>((uint8_t*)buffer_ptr,
+                                     (uint8_t*)buffer_ptr + buffer_size);
+  auto result = kernel_state()->content_manager()->SetContentThumbnail(
       content_data, std::move(buffer));
 
   if (overlapped_ptr) {
-    kernel_state->CompleteOverlappedImmediate(overlapped_ptr, result);
-    SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
+    kernel_state()->CompleteOverlappedImmediate(overlapped_ptr, result);
+    return X_ERROR_IO_PENDING;
   } else {
-    SHIM_SET_RETURN_32(result);
+    return result;
   }
 }
+DECLARE_XAM_EXPORT1(XamContentSetThumbnail, kContent, kImplemented);
 
-SHIM_CALL XamContentDelete_shim(PPCContext* ppc_context,
-                                KernelState* kernel_state) {
-  uint32_t user_index = SHIM_GET_ARG_32(0);
-  uint32_t content_data_ptr = SHIM_GET_ARG_32(1);
-  uint32_t overlapped_ptr = SHIM_GET_ARG_32(2);
+dword_result_t XamContentDelete(dword_t user_index, lpvoid_t content_data_ptr,
+                                lpunknown_t overlapped_ptr) {
+  auto content_data = XCONTENT_DATA((uint8_t*)content_data_ptr);
 
-  auto content_data = XCONTENT_DATA(SHIM_MEM_ADDR(content_data_ptr));
-
-  XELOGD("XamContentDelete(%d, %.8X, %.8X)", user_index, content_data_ptr,
-         overlapped_ptr);
-
-  auto result = kernel_state->content_manager()->DeleteContent(content_data);
+  auto result = kernel_state()->content_manager()->DeleteContent(content_data);
 
   if (overlapped_ptr) {
-    kernel_state->CompleteOverlappedImmediate(overlapped_ptr, result);
-    SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
+    kernel_state()->CompleteOverlappedImmediate(overlapped_ptr, result);
+    return X_ERROR_IO_PENDING;
   } else {
-    SHIM_SET_RETURN_32(result);
+    return result;
   }
 }
+DECLARE_XAM_EXPORT1(XamContentDelete, kContent, kImplemented);
 
 void RegisterContentExports(xe::cpu::ExportResolver* export_resolver,
-                            KernelState* kernel_state) {
-  SHIM_SET_MAPPING("xam.xex", XamContentGetLicenseMask, state);
-  SHIM_SET_MAPPING("xam.xex", XamContentGetDeviceName, state);
-  SHIM_SET_MAPPING("xam.xex", XamContentGetDeviceState, state);
-  SHIM_SET_MAPPING("xam.xex", XamContentGetDeviceData, state);
-  SHIM_SET_MAPPING("xam.xex", XamContentResolve, state);
-  SHIM_SET_MAPPING("xam.xex", XamContentFlush, state);
-  SHIM_SET_MAPPING("xam.xex", XamContentClose, state);
-  SHIM_SET_MAPPING("xam.xex", XamContentGetCreator, state);
-  SHIM_SET_MAPPING("xam.xex", XamContentGetThumbnail, state);
-  SHIM_SET_MAPPING("xam.xex", XamContentSetThumbnail, state);
-  SHIM_SET_MAPPING("xam.xex", XamContentDelete, state);
-}
+                            KernelState* kernel_state) {}
 
 }  // namespace xam
 }  // namespace kernel
diff --git a/src/xenia/kernel/xam/xam_info.cc b/src/xenia/kernel/xam/xam_info.cc
index b4afb14ba..89feec37e 100644
--- a/src/xenia/kernel/xam/xam_info.cc
+++ b/src/xenia/kernel/xam/xam_info.cc
@@ -17,6 +17,10 @@
 #include "xenia/kernel/xthread.h"
 #include "xenia/xbox.h"
 
+#if XE_PLATFORM_WIN32
+#include "xenia/base/platform_win.h"
+#endif
+
 namespace xe {
 namespace kernel {
 namespace xam {
@@ -24,6 +28,157 @@ namespace xam {
 constexpr uint32_t X_LANGUAGE_ENGLISH = 1;
 constexpr uint32_t X_LANGUAGE_JAPANESE = 2;
 
+dword_result_t XamFeatureEnabled(dword_t unk) { return 0; }
+DECLARE_XAM_EXPORT1(XamFeatureEnabled, kNone, kStub);
+
+// Empty stub schema binary.
+uint8_t schema_bin[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00,
+    0x00, 0x2C, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2C, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
+};
+
+dword_result_t XamGetOnlineSchema() {
+  static uint32_t schema_guest = 0;
+
+  if (!schema_guest) {
+    schema_guest =
+        kernel_state()->memory()->SystemHeapAlloc(8 + sizeof(schema_bin));
+    auto schema = kernel_state()->memory()->TranslateVirtual(schema_guest);
+    std::memcpy(schema + 8, schema_bin, sizeof(schema_bin));
+    xe::store_and_swap<uint32_t>(schema + 0, schema_guest + 8);
+    xe::store_and_swap<uint32_t>(schema + 4, sizeof(schema_bin));
+  }
+
+  // return pointer to the schema ptr/schema size struct
+  return schema_guest;
+}
+DECLARE_XAM_EXPORT1(XamGetOnlineSchema, kNone, kImplemented);
+
+void XamFormatDateString(dword_t unk, qword_t filetime, lpvoid_t buffer,
+                         dword_t buffer_length) {
+  std::memset(buffer, 0, buffer_length * 2);
+
+// TODO: implement this for other platforms
+#if XE_PLATFORM_WIN32
+  FILETIME t;
+  t.dwHighDateTime = filetime >> 32;
+  t.dwLowDateTime = (uint32_t)filetime;
+
+  SYSTEMTIME st;
+  SYSTEMTIME stLocal;
+
+  FileTimeToSystemTime(&t, &st);
+  SystemTimeToTzSpecificLocalTime(NULL, &st, &stLocal);
+
+  wchar_t buf[256];
+  // TODO: format this depending on users locale?
+  swprintf(buf, 256, L"%02d/%02d/%d", stLocal.wMonth, stLocal.wDay,
+           stLocal.wYear);
+
+  xe::copy_and_swap((wchar_t*)buffer.host_address(), buf, buffer_length);
+#else
+  assert_always();
+#endif
+}
+DECLARE_XAM_EXPORT1(XamFormatDateString, kNone, kImplemented);
+
+void XamFormatTimeString(dword_t unk, qword_t filetime, lpvoid_t buffer,
+                         dword_t buffer_length) {
+  std::memset(buffer, 0, buffer_length * 2);
+
+// TODO: implement this for other platforms
+#if XE_PLATFORM_WIN32
+  FILETIME t;
+  t.dwHighDateTime = filetime >> 32;
+  t.dwLowDateTime = (uint32_t)filetime;
+
+  SYSTEMTIME st;
+  SYSTEMTIME stLocal;
+
+  FileTimeToSystemTime(&t, &st);
+  SystemTimeToTzSpecificLocalTime(NULL, &st, &stLocal);
+
+  wchar_t buf[256];
+  swprintf(buf, 256, L"%02d:%02d", stLocal.wHour, stLocal.wMinute);
+
+  xe::copy_and_swap((wchar_t*)buffer.host_address(), buf, buffer_length);
+#else
+  assert_always();
+#endif
+}
+DECLARE_XAM_EXPORT1(XamFormatTimeString, kNone, kImplemented);
+
+dword_result_t keXamBuildResourceLocator(uint64_t module,
+                                         const wchar_t* container,
+                                         const wchar_t* resource,
+                                         lpvoid_t buffer,
+                                         uint32_t buffer_length) {
+  wchar_t buf[256];
+
+  if (!module) {
+    swprintf(buf, 256, L"file://media:/%s.xzp#%s", container, resource);
+    XELOGD(
+        "XamBuildResourceLocator(%ws) returning locator to local file %ws.xzp",
+        container, container);
+  } else {
+    swprintf(buf, 256, L"section://%X,%s#%s", (uint32_t)module, container,
+             resource);
+  }
+
+  xe::copy_and_swap((wchar_t*)buffer.host_address(), buf, buffer_length);
+  return 0;
+}
+
+dword_result_t XamBuildResourceLocator(qword_t module, lpwstring_t container,
+                                       lpwstring_t resource, lpvoid_t buffer,
+                                       dword_t buffer_length) {
+  return keXamBuildResourceLocator(module, container.value().c_str(),
+                                   resource.value().c_str(), buffer,
+                                   buffer_length);
+}
+DECLARE_XAM_EXPORT1(XamBuildResourceLocator, kNone, kImplemented);
+
+dword_result_t XamBuildGamercardResourceLocator(lpwstring_t filename,
+                                                lpvoid_t buffer,
+                                                dword_t buffer_length) {
+  // On an actual xbox these funcs would return a locator to xam.xex resources,
+  // but for Xenia we can return a locator to the resources as local files. (big
+  // thanks to MS for letting XamBuildResourceLocator return local file
+  // locators!)
+
+  // If you're running an app that'll need them, make sure to extract xam.xex
+  // resources with xextool ("xextool -d . xam.xex") and add a .xzp extension.
+
+  return keXamBuildResourceLocator(0, L"gamercrd", filename.value().c_str(),
+                                   buffer, buffer_length);
+}
+DECLARE_XAM_EXPORT1(XamBuildGamercardResourceLocator, kNone, kImplemented);
+
+dword_result_t XamBuildSharedSystemResourceLocator(lpwstring_t filename,
+                                                   lpvoid_t buffer,
+                                                   dword_t buffer_length) {
+  // see notes inside XamBuildGamercardResourceLocator above
+  return keXamBuildResourceLocator(0, L"shrdres", filename.value().c_str(),
+                                   buffer, buffer_length);
+}
+DECLARE_XAM_EXPORT1(XamBuildSharedSystemResourceLocator, kNone, kImplemented);
+
+dword_result_t XamBuildLegacySystemResourceLocator(lpwstring_t filename,
+                                                   lpvoid_t buffer,
+                                                   dword_t buffer_length) {
+  return XamBuildSharedSystemResourceLocator(filename, buffer, buffer_length);
+}
+DECLARE_XAM_EXPORT1(XamBuildLegacySystemResourceLocator, kNone, kImplemented);
+
+dword_result_t XamBuildXamResourceLocator(lpwstring_t filename, lpvoid_t buffer,
+                                          dword_t buffer_length) {
+  return keXamBuildResourceLocator(0, L"xam", filename.value().c_str(), buffer,
+                                   buffer_length);
+}
+DECLARE_XAM_EXPORT1(XamBuildXamResourceLocator, kNone, kImplemented);
+
 dword_result_t XamGetSystemVersion() {
   // eh, just picking one. If we go too low we may break new games, but
   // this value seems to be used for conditionally loading symbols and if
@@ -32,12 +187,12 @@ dword_result_t XamGetSystemVersion() {
   // 0x20096B00
   return 0;
 }
-DECLARE_XAM_EXPORT(XamGetSystemVersion, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamGetSystemVersion, kNone, kStub);
 
 void XCustomRegisterDynamicActions() {
   // ???
 }
-DECLARE_XAM_EXPORT(XCustomRegisterDynamicActions, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XCustomRegisterDynamicActions, kNone, kStub);
 
 dword_result_t XGetAVPack() {
   // DWORD
@@ -47,10 +202,10 @@ dword_result_t XGetAVPack() {
   // they explode with errors if not in PAL mode.
   return 6;
 }
-DECLARE_XAM_EXPORT(XGetAVPack, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XGetAVPack, kNone, kStub);
 
 dword_result_t XGetGameRegion() { return 0xFFFF; }
-DECLARE_XAM_EXPORT(XGetGameRegion, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XGetGameRegion, kNone, kStub);
 
 dword_result_t XGetLanguage() {
   uint32_t desired_language = X_LANGUAGE_ENGLISH;
@@ -67,7 +222,7 @@ dword_result_t XGetLanguage() {
 
   return desired_language;
 }
-DECLARE_XAM_EXPORT(XGetLanguage, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XGetLanguage, kNone, kImplemented);
 
 dword_result_t XamGetExecutionId(lpdword_t info_ptr) {
   auto module = kernel_state()->GetExecutableModule();
@@ -84,38 +239,34 @@ dword_result_t XamGetExecutionId(lpdword_t info_ptr) {
   *info_ptr = guest_hdr_ptr;
   return X_STATUS_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamGetExecutionId, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamGetExecutionId, kNone, kImplemented);
 
 dword_result_t XamLoaderSetLaunchData(lpvoid_t data, dword_t size) {
   auto xam = kernel_state()->GetKernelModule<XamModule>("xam.xex");
-
   auto& loader_data = xam->loader_data();
   loader_data.launch_data_present = size ? true : false;
   loader_data.launch_data.resize(size);
   std::memcpy(loader_data.launch_data.data(), data, size);
-
-  // FIXME: Unknown return value.
   return 0;
 }
-DECLARE_XAM_EXPORT(XamLoaderSetLaunchData, ExportTag::kSketchy);
+DECLARE_XAM_EXPORT1(XamLoaderSetLaunchData, kNone, kSketchy);
 
 dword_result_t XamLoaderGetLaunchDataSize(lpdword_t size_ptr) {
-  auto xam = kernel_state()->GetKernelModule<XamModule>("xam.xex");
-  auto& loader_data = xam->loader_data();
-
   if (!size_ptr) {
     return X_ERROR_INVALID_PARAMETER;
   }
 
-  if (loader_data.launch_data_present) {
-    *size_ptr = uint32_t(xam->loader_data().launch_data.size());
-    return X_ERROR_SUCCESS;
+  auto xam = kernel_state()->GetKernelModule<XamModule>("xam.xex");
+  auto& loader_data = xam->loader_data();
+  if (!loader_data.launch_data_present) {
+    *size_ptr = 0;
+    return X_ERROR_NOT_FOUND;
   }
 
-  *size_ptr = 0;
-  return X_ERROR_NOT_FOUND;
+  *size_ptr = uint32_t(xam->loader_data().launch_data.size());
+  return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamLoaderGetLaunchDataSize, ExportTag::kSketchy);
+DECLARE_XAM_EXPORT1(XamLoaderGetLaunchDataSize, kNone, kSketchy);
 
 dword_result_t XamLoaderGetLaunchData(lpvoid_t buffer_ptr,
                                       dword_t buffer_size) {
@@ -130,7 +281,7 @@ dword_result_t XamLoaderGetLaunchData(lpvoid_t buffer_ptr,
   std::memcpy(buffer_ptr, loader_data.launch_data.data(), copy_size);
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamLoaderGetLaunchData, ExportTag::kSketchy);
+DECLARE_XAM_EXPORT1(XamLoaderGetLaunchData, kNone, kSketchy);
 
 void XamLoaderLaunchTitle(lpstring_t raw_name, dword_t flags) {
   auto xam = kernel_state()->GetKernelModule<XamModule>("xam.xex");
@@ -158,13 +309,13 @@ void XamLoaderLaunchTitle(lpstring_t raw_name, dword_t flags) {
   // This function does not return.
   kernel_state()->TerminateTitle();
 }
-DECLARE_XAM_EXPORT(XamLoaderLaunchTitle, ExportTag::kSketchy);
+DECLARE_XAM_EXPORT1(XamLoaderLaunchTitle, kNone, kSketchy);
 
 void XamLoaderTerminateTitle() {
   // This function does not return.
   kernel_state()->TerminateTitle();
 }
-DECLARE_XAM_EXPORT(XamLoaderTerminateTitle, ExportTag::kSketchy);
+DECLARE_XAM_EXPORT1(XamLoaderTerminateTitle, kNone, kSketchy);
 
 dword_result_t XamAlloc(dword_t unk, dword_t size, lpdword_t out_ptr) {
   assert_true(unk == 0);
@@ -176,14 +327,14 @@ dword_result_t XamAlloc(dword_t unk, dword_t size, lpdword_t out_ptr) {
 
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamAlloc, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamAlloc, kMemory, kImplemented);
 
 dword_result_t XamFree(lpdword_t ptr) {
   kernel_state()->memory()->SystemHeapFree(ptr.guest_address());
 
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamFree, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamFree, kMemory, kImplemented);
 
 // https://github.com/LestaD/SourceEngine2007/blob/master/se2007/engine/xboxsystem.cpp#L518
 dword_result_t XamEnumerate(dword_t handle, dword_t flags, lpvoid_t buffer,
@@ -202,18 +353,30 @@ dword_result_t XamEnumerate(dword_t handle, dword_t flags, lpvoid_t buffer,
     }
   }
 
-  buffer.Zero(buffer_length);
+  size_t actual_buffer_length = (uint32_t)buffer_length;
+  if (buffer_length == e->items_per_enumerate()) {
+    actual_buffer_length = e->item_size() * e->items_per_enumerate();
+    // Known culprits:
+    //   Final Fight: Double Impact (saves)
+    XELOGW(
+        "Broken usage of XamEnumerate! buffer length=%.X vs actual length=%.X "
+        "(item size=%.X, items per enumerate=%u)",
+        (uint32_t)buffer_length, actual_buffer_length, e->item_size(),
+        e->items_per_enumerate());
+  }
+
+  buffer.Zero(actual_buffer_length);
 
   X_RESULT result;
   uint32_t item_count = 0;
 
-  if (buffer_length < e->item_size()) {
+  if (actual_buffer_length < e->item_size()) {
     result = X_ERROR_INSUFFICIENT_BUFFER;
   } else if (e->current_item() >= e->item_count()) {
     result = X_ERROR_NO_MORE_FILES;
   } else {
     auto item_buffer = buffer.as<uint8_t*>();
-    auto max_items = buffer_length / e->item_size();
+    auto max_items = actual_buffer_length / e->item_size();
     while (max_items--) {
       if (!e->WriteItem(item_buffer)) {
         break;
@@ -224,8 +387,6 @@ dword_result_t XamEnumerate(dword_t handle, dword_t flags, lpvoid_t buffer,
     result = X_ERROR_SUCCESS;
   }
 
-  // Return X_ERROR_NO_MORE_FILES in HRESULT form.
-  X_HRESULT extended_result = result != 0 ? X_HRESULT_FROM_WIN32(result) : 0;
   if (items_returned) {
     assert_true(!overlapped);
     *items_returned = result == X_ERROR_SUCCESS ? item_count : 0;
@@ -233,7 +394,9 @@ dword_result_t XamEnumerate(dword_t handle, dword_t flags, lpvoid_t buffer,
   } else if (overlapped) {
     assert_true(!items_returned);
     kernel_state()->CompleteOverlappedImmediateEx(
-        overlapped, result, extended_result,
+        overlapped,
+        result == X_ERROR_SUCCESS ? X_ERROR_SUCCESS : X_ERROR_FUNCTION_FAILED,
+        X_HRESULT_FROM_WIN32(result),
         result == X_ERROR_SUCCESS ? item_count : 0);
     return X_ERROR_IO_PENDING;
   } else {
@@ -241,7 +404,7 @@ dword_result_t XamEnumerate(dword_t handle, dword_t flags, lpvoid_t buffer,
     return X_ERROR_INVALID_PARAMETER;
   }
 }
-DECLARE_XAM_EXPORT(XamEnumerate, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamEnumerate, kNone, kImplemented);
 
 dword_result_t XamCreateEnumeratorHandle(unknown_t unk1, unknown_t unk2,
                                          unknown_t unk3, unknown_t unk4,
@@ -249,13 +412,19 @@ dword_result_t XamCreateEnumeratorHandle(unknown_t unk1, unknown_t unk2,
                                          unknown_t unk7, unknown_t unk8) {
   return X_ERROR_INVALID_PARAMETER;
 }
-DECLARE_XAM_EXPORT(XamCreateEnumeratorHandle, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamCreateEnumeratorHandle, kNone, kStub);
 
 dword_result_t XamGetPrivateEnumStructureFromHandle(unknown_t unk1,
                                                     unknown_t unk2) {
   return X_ERROR_INVALID_PARAMETER;
 }
-DECLARE_XAM_EXPORT(XamGetPrivateEnumStructureFromHandle, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamGetPrivateEnumStructureFromHandle, kNone, kStub);
+
+dword_result_t XamQueryLiveHiveW(lpwstring_t name, lpvoid_t out_buf,
+                                 dword_t out_size, dword_t type /* guess */) {
+  return X_STATUS_INVALID_PARAMETER_1;
+}
+DECLARE_XAM_EXPORT1(XamQueryLiveHiveW, kNone, kStub);
 
 void RegisterInfoExports(xe::cpu::ExportResolver* export_resolver,
                          KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xam/xam_input.cc b/src/xenia/kernel/xam/xam_input.cc
index 164d36651..7aead257d 100644
--- a/src/xenia/kernel/xam/xam_input.cc
+++ b/src/xenia/kernel/xam/xam_input.cc
@@ -31,15 +31,14 @@ constexpr uint32_t XINPUT_FLAG_ANY_USER = 1 << 30;
 void XamResetInactivity() {
   // Do we need to do anything?
 }
-DECLARE_XAM_EXPORT(XamResetInactivity, ExportTag::kInput | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamResetInactivity, kInput, kStub);
 
 dword_result_t XamEnableInactivityProcessing(dword_t unk, dword_t enable) {
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamEnableInactivityProcessing,
-                   ExportTag::kInput | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamEnableInactivityProcessing, kInput, kStub);
 
-// http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputgetcapabilities(v=vs.85).aspx
+// https://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputgetcapabilities(v=vs.85).aspx
 dword_result_t XamInputGetCapabilities(dword_t user_index, dword_t flags,
                                        pointer_t<X_INPUT_CAPABILITIES> caps) {
   if (!caps) {
@@ -60,8 +59,7 @@ dword_result_t XamInputGetCapabilities(dword_t user_index, dword_t flags,
   auto input_system = kernel_state()->emulator()->input_system();
   return input_system->GetCapabilities(actual_user_index, flags, caps);
 }
-DECLARE_XAM_EXPORT(XamInputGetCapabilities,
-                   ExportTag::kInput | ExportTag::kSketchy);
+DECLARE_XAM_EXPORT1(XamInputGetCapabilities, kInput, kSketchy);
 
 dword_result_t XamInputGetCapabilitiesEx(dword_t unk, dword_t user_index,
                                          dword_t flags,
@@ -84,10 +82,9 @@ dword_result_t XamInputGetCapabilitiesEx(dword_t unk, dword_t user_index,
   auto input_system = kernel_state()->emulator()->input_system();
   return input_system->GetCapabilities(actual_user_index, flags, caps);
 }
-DECLARE_XAM_EXPORT(XamInputGetCapabilitiesEx,
-                   ExportTag::kInput | ExportTag::kSketchy);
+DECLARE_XAM_EXPORT1(XamInputGetCapabilitiesEx, kInput, kSketchy);
 
-// http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputgetstate(v=vs.85).aspx
+// https://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputgetstate(v=vs.85).aspx
 dword_result_t XamInputGetState(dword_t user_index, dword_t flags,
                                 pointer_t<X_INPUT_STATE> input_state) {
   // Games call this with a NULL state ptr, probably as a query.
@@ -106,10 +103,9 @@ dword_result_t XamInputGetState(dword_t user_index, dword_t flags,
   auto input_system = kernel_state()->emulator()->input_system();
   return input_system->GetState(user_index, input_state);
 }
-DECLARE_XAM_EXPORT(XamInputGetState,
-                   ExportTag::kInput | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamInputGetState, kInput, kImplemented);
 
-// http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputsetstate(v=vs.85).aspx
+// https://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputsetstate(v=vs.85).aspx
 dword_result_t XamInputSetState(dword_t user_index, dword_t unk,
                                 pointer_t<X_INPUT_VIBRATION> vibration) {
   if (!vibration) {
@@ -125,13 +121,12 @@ dword_result_t XamInputSetState(dword_t user_index, dword_t unk,
   auto input_system = kernel_state()->emulator()->input_system();
   return input_system->SetState(user_index, vibration);
 }
-DECLARE_XAM_EXPORT(XamInputSetState,
-                   ExportTag::kInput | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamInputSetState, kInput, kImplemented);
 
-// http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputgetkeystroke(v=vs.85).aspx
+// https://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputgetkeystroke(v=vs.85).aspx
 dword_result_t XamInputGetKeystroke(dword_t user_index, dword_t flags,
                                     pointer_t<X_INPUT_KEYSTROKE> keystroke) {
-  // http://ffplay360.googlecode.com/svn/Test/Common/AtgXime.cpp
+  // https://github.com/CodeAsm/ffplay360/blob/master/Common/AtgXime.cpp
   // user index = index or XUSER_INDEX_ANY
   // flags = XINPUT_FLAG_GAMEPAD (| _ANYUSER | _ANYDEVICE)
 
@@ -153,8 +148,7 @@ dword_result_t XamInputGetKeystroke(dword_t user_index, dword_t flags,
   auto input_system = kernel_state()->emulator()->input_system();
   return input_system->GetKeystroke(user_index, flags, keystroke);
 }
-DECLARE_XAM_EXPORT(XamInputGetKeystroke,
-                   ExportTag::kInput | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamInputGetKeystroke, kInput, kImplemented);
 
 // Same as non-ex, just takes a pointer to user index.
 dword_result_t XamInputGetKeystrokeEx(lpdword_t user_index_ptr, dword_t flags,
@@ -181,8 +175,7 @@ dword_result_t XamInputGetKeystrokeEx(lpdword_t user_index_ptr, dword_t flags,
   }
   return result;
 }
-DECLARE_XAM_EXPORT(XamInputGetKeystrokeEx,
-                   ExportTag::kInput | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamInputGetKeystrokeEx, kInput, kImplemented);
 
 X_HRESULT_result_t XamUserGetDeviceContext(dword_t user_index, dword_t unk,
                                            lpdword_t out_ptr) {
@@ -196,8 +189,7 @@ X_HRESULT_result_t XamUserGetDeviceContext(dword_t user_index, dword_t unk,
     return X_E_DEVICE_NOT_CONNECTED;
   }
 }
-DECLARE_XAM_EXPORT(XamUserGetDeviceContext,
-                   ExportTag::kInput | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamUserGetDeviceContext, kInput, kStub);
 
 void RegisterInputExports(xe::cpu::ExportResolver* export_resolver,
                           KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xam/xam_msg.cc b/src/xenia/kernel/xam/xam_msg.cc
index a1e7a3156..07d0be6c7 100644
--- a/src/xenia/kernel/xam/xam_msg.cc
+++ b/src/xenia/kernel/xam/xam_msg.cc
@@ -23,22 +23,22 @@ dword_result_t XMsgInProcessCall(dword_t app, dword_t message, dword_t arg1,
   auto result = kernel_state()->app_manager()->DispatchMessageSync(app, message,
                                                                    arg1, arg2);
   if (result == X_ERROR_NOT_FOUND) {
-    XELOGE("XMsgInProcessCall: app %.8X undefined", app);
+    XELOGE("XMsgInProcessCall: app %.8X undefined", (uint32_t)app);
   }
   return result;
 }
-DECLARE_XAM_EXPORT(XMsgInProcessCall, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XMsgInProcessCall, kNone, kImplemented);
 
 dword_result_t XMsgSystemProcessCall(dword_t app, dword_t message,
                                      dword_t buffer, dword_t buffer_length) {
   auto result = kernel_state()->app_manager()->DispatchMessageAsync(
       app, message, buffer, buffer_length);
   if (result == X_ERROR_NOT_FOUND) {
-    XELOGE("XMsgSystemProcessCall: app %.8X undefined", app);
+    XELOGE("XMsgSystemProcessCall: app %.8X undefined", (uint32_t)app);
   }
   return result;
 }
-DECLARE_XAM_EXPORT(XMsgSystemProcessCall, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XMsgSystemProcessCall, kNone, kImplemented);
 
 dword_result_t XMsgStartIORequest(dword_t app, dword_t message,
                                   pointer_t<XAM_OVERLAPPED> overlapped_ptr,
@@ -46,7 +46,7 @@ dword_result_t XMsgStartIORequest(dword_t app, dword_t message,
   auto result = kernel_state()->app_manager()->DispatchMessageAsync(
       app, message, buffer, buffer_length);
   if (result == X_ERROR_NOT_FOUND) {
-    XELOGE("XMsgStartIORequest: app %.8X undefined", app);
+    XELOGE("XMsgStartIORequest: app %.8X undefined", (uint32_t)app);
   }
   if (overlapped_ptr) {
     kernel_state()->CompleteOverlappedImmediate(overlapped_ptr, result);
@@ -54,7 +54,7 @@ dword_result_t XMsgStartIORequest(dword_t app, dword_t message,
   }
   return result;
 }
-DECLARE_XAM_EXPORT(XMsgStartIORequest, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XMsgStartIORequest, kNone, kImplemented);
 
 dword_result_t XMsgStartIORequestEx(dword_t app, dword_t message,
                                     pointer_t<XAM_OVERLAPPED> overlapped_ptr,
@@ -63,7 +63,7 @@ dword_result_t XMsgStartIORequestEx(dword_t app, dword_t message,
   auto result = kernel_state()->app_manager()->DispatchMessageAsync(
       app, message, buffer, buffer_length);
   if (result == X_ERROR_NOT_FOUND) {
-    XELOGE("XMsgStartIORequestEx: app %.8X undefined", app);
+    XELOGE("XMsgStartIORequestEx: app %.8X undefined", (uint32_t)app);
   }
   if (overlapped_ptr) {
     kernel_state()->CompleteOverlappedImmediate(overlapped_ptr, result);
@@ -71,7 +71,7 @@ dword_result_t XMsgStartIORequestEx(dword_t app, dword_t message,
   }
   return result;
 }
-DECLARE_XAM_EXPORT(XMsgStartIORequestEx, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XMsgStartIORequestEx, kNone, kImplemented);
 
 dword_result_t XMsgCancelIORequest(pointer_t<XAM_OVERLAPPED> overlapped_ptr,
                                    dword_t wait) {
@@ -86,7 +86,7 @@ dword_result_t XMsgCancelIORequest(pointer_t<XAM_OVERLAPPED> overlapped_ptr,
 
   return 0;
 }
-DECLARE_XAM_EXPORT(XMsgCancelIORequest, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XMsgCancelIORequest, kNone, kImplemented);
 
 void RegisterMsgExports(xe::cpu::ExportResolver* export_resolver,
                         KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xam/xam_net.cc b/src/xenia/kernel/xam/xam_net.cc
index 9016ffb94..d0a3d70c3 100644
--- a/src/xenia/kernel/xam/xam_net.cc
+++ b/src/xenia/kernel/xam/xam_net.cc
@@ -170,8 +170,7 @@ dword_result_t NetDll_XNetStartup(dword_t caller,
 
   return 0;
 }
-DECLARE_XAM_EXPORT(NetDll_XNetStartup,
-                   ExportTag::kNetworking | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(NetDll_XNetStartup, kNetworking, kImplemented);
 
 dword_result_t NetDll_XNetCleanup(dword_t caller, lpvoid_t params) {
   auto xam = kernel_state()->GetKernelModule<XamModule>("xam.xex");
@@ -183,8 +182,7 @@ dword_result_t NetDll_XNetCleanup(dword_t caller, lpvoid_t params) {
 
   return 0;
 }
-DECLARE_XAM_EXPORT(NetDll_XNetCleanup,
-                   ExportTag::kNetworking | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(NetDll_XNetCleanup, kNetworking, kImplemented);
 
 dword_result_t NetDll_XNetGetOpt(dword_t one, dword_t option_id,
                                  lpvoid_t buffer_ptr, lpdword_t buffer_size) {
@@ -202,7 +200,7 @@ dword_result_t NetDll_XNetGetOpt(dword_t one, dword_t option_id,
       return 0x2726;  // WSAEINVAL
   }
 }
-DECLARE_XAM_EXPORT(NetDll_XNetGetOpt, ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_XNetGetOpt, kNetworking, kSketchy);
 
 dword_result_t NetDll_XNetRandom(dword_t caller, lpvoid_t buffer_ptr,
                                  dword_t length) {
@@ -212,8 +210,7 @@ dword_result_t NetDll_XNetRandom(dword_t caller, lpvoid_t buffer_ptr,
 
   return 0;
 }
-DECLARE_XAM_EXPORT(NetDll_XNetRandom,
-                   ExportTag::kNetworking | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(NetDll_XNetRandom, kNetworking, kStub);
 
 dword_result_t NetDll_WSAStartup(dword_t caller, word_t version,
                                  pointer_t<X_WSADATA> data_ptr) {
@@ -263,19 +260,16 @@ dword_result_t NetDll_WSAStartup(dword_t caller, word_t version,
 
   return ret;
 }
-DECLARE_XAM_EXPORT(NetDll_WSAStartup,
-                   ExportTag::kNetworking | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(NetDll_WSAStartup, kNetworking, kImplemented);
 
 dword_result_t NetDll_WSACleanup(dword_t caller) {
   // This does nothing. Xenia needs WSA running.
   return 0;
 }
-DECLARE_XAM_EXPORT(NetDll_WSACleanup,
-                   ExportTag::kNetworking | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(NetDll_WSACleanup, kNetworking, kImplemented);
 
 dword_result_t NetDll_WSAGetLastError() { return XThread::GetLastError(); }
-DECLARE_XAM_EXPORT(NetDll_WSAGetLastError,
-                   ExportTag::kNetworking | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(NetDll_WSAGetLastError, kNetworking, kImplemented);
 
 dword_result_t NetDll_WSARecvFrom(dword_t caller, dword_t socket,
                                   pointer_t<XWSABUF> buffers_ptr,
@@ -295,7 +289,7 @@ dword_result_t NetDll_WSARecvFrom(dword_t caller, dword_t socket,
 
   return 0;
 }
-DECLARE_XAM_EXPORT(NetDll_WSARecvFrom, ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_WSARecvFrom, kNetworking, kStub);
 
 // If the socket is a VDP socket, buffer 0 is the game data length, and buffer 1
 // is the unencrypted game data.
@@ -340,8 +334,7 @@ dword_result_t NetDll_WSASendTo(dword_t caller, dword_t socket_handle,
 
   return 0;
 }
-DECLARE_XAM_EXPORT(NetDll_WSASendTo,
-                   ExportTag::kNetworking | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(NetDll_WSASendTo, kNetworking, kImplemented);
 
 dword_result_t NetDll_WSAWaitForMultipleEvents(dword_t num_events,
                                                lpdword_t events,
@@ -357,65 +350,60 @@ dword_result_t NetDll_WSAWaitForMultipleEvents(dword_t num_events,
 
   X_STATUS result = 0;
   do {
-    result = xboxkrnl::NtWaitForMultipleObjectsEx(
+    result = xboxkrnl::xeNtWaitForMultipleObjectsEx(
         num_events, events, wait_all, 1, alertable,
         timeout != -1 ? &timeout_wait : nullptr);
   } while (result == X_STATUS_ALERTED);
 
   if (XFAILED(result)) {
-    uint32_t error = xboxkrnl::RtlNtStatusToDosError(result);
+    uint32_t error = xboxkrnl::xeRtlNtStatusToDosError(result);
     XThread::SetLastError(error);
     return ~0u;
   }
   return 0;
 }
-DECLARE_XAM_EXPORT(NetDll_WSAWaitForMultipleEvents, ExportTag::kNetworking |
-                                                        ExportTag::kThreading |
-                                                        ExportTag::kBlocking);
+DECLARE_XAM_EXPORT2(NetDll_WSAWaitForMultipleEvents, kNetworking, kImplemented,
+                    kBlocking);
 
 dword_result_t NetDll_WSACreateEvent() {
   XEvent* ev = new XEvent(kernel_state());
   ev->Initialize(true, false);
   return ev->handle();
 }
-DECLARE_XAM_EXPORT(NetDll_WSACreateEvent,
-                   ExportTag::kNetworking | ExportTag::kThreading);
+DECLARE_XAM_EXPORT1(NetDll_WSACreateEvent, kNetworking, kImplemented);
 
 dword_result_t NetDll_WSACloseEvent(dword_t event_handle) {
   X_STATUS result = kernel_state()->object_table()->ReleaseHandle(event_handle);
   if (XFAILED(result)) {
-    uint32_t error = xboxkrnl::RtlNtStatusToDosError(result);
+    uint32_t error = xboxkrnl::xeRtlNtStatusToDosError(result);
     XThread::SetLastError(error);
     return 0;
   }
   return 1;
 }
-DECLARE_XAM_EXPORT(NetDll_WSACloseEvent,
-                   ExportTag::kNetworking | ExportTag::kThreading);
+DECLARE_XAM_EXPORT1(NetDll_WSACloseEvent, kNetworking, kImplemented);
 
 dword_result_t NetDll_WSAResetEvent(dword_t event_handle) {
-  X_STATUS result = xboxkrnl::NtClearEvent(event_handle);
+  X_STATUS result = xboxkrnl::xeNtClearEvent(event_handle);
   if (XFAILED(result)) {
-    uint32_t error = xboxkrnl::RtlNtStatusToDosError(result);
+    uint32_t error = xboxkrnl::xeRtlNtStatusToDosError(result);
     XThread::SetLastError(error);
     return 0;
   }
   return 1;
 }
-DECLARE_XAM_EXPORT(NetDll_WSAResetEvent,
-                   ExportTag::kNetworking | ExportTag::kThreading);
+DECLARE_XAM_EXPORT1(NetDll_WSAResetEvent, kNetworking, kImplemented);
 
 dword_result_t NetDll_WSASetEvent(dword_t event_handle) {
-  X_STATUS result = xboxkrnl::NtSetEvent(event_handle, nullptr);
+  X_STATUS result = xboxkrnl::xeNtSetEvent(event_handle, nullptr);
   if (XFAILED(result)) {
-    uint32_t error = xboxkrnl::RtlNtStatusToDosError(result);
+    uint32_t error = xboxkrnl::xeRtlNtStatusToDosError(result);
     XThread::SetLastError(error);
     return 0;
   }
   return 1;
 }
-DECLARE_XAM_EXPORT(NetDll_WSASetEvent,
-                   ExportTag::kNetworking | ExportTag::kThreading);
+DECLARE_XAM_EXPORT1(NetDll_WSASetEvent, kNetworking, kImplemented);
 
 struct XnAddrStatus {
   // Address acquisition is not yet complete
@@ -452,8 +440,7 @@ dword_result_t NetDll_XNetGetTitleXnAddr(dword_t caller,
 
   return XnAddrStatus::XNET_GET_XNADDR_STATIC;
 }
-DECLARE_XAM_EXPORT(NetDll_XNetGetTitleXnAddr,
-                   ExportTag::kNetworking | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(NetDll_XNetGetTitleXnAddr, kNetworking, kStub);
 
 dword_result_t NetDll_XNetGetDebugXnAddr(dword_t caller,
                                          pointer_t<XNADDR> addr_ptr) {
@@ -462,8 +449,7 @@ dword_result_t NetDll_XNetGetDebugXnAddr(dword_t caller,
   // XNET_GET_XNADDR_NONE causes caller to gracefully return.
   return XnAddrStatus::XNET_GET_XNADDR_NONE;
 }
-DECLARE_XAM_EXPORT(NetDll_XNetGetDebugXnAddr,
-                   ExportTag::kNetworking | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(NetDll_XNetGetDebugXnAddr, kNetworking, kStub);
 
 dword_result_t NetDll_XNetXnAddrToMachineId(dword_t caller,
                                             pointer_t<XNADDR> addr_ptr,
@@ -471,15 +457,13 @@ dword_result_t NetDll_XNetXnAddrToMachineId(dword_t caller,
   // Tell the caller we're not signed in to live (non-zero ret)
   return 1;
 }
-DECLARE_XAM_EXPORT(NetDll_XNetXnAddrToMachineId,
-                   ExportTag::kNetworking | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(NetDll_XNetXnAddrToMachineId, kNetworking, kStub);
 
 void NetDll_XNetInAddrToString(dword_t caller, dword_t in_addr,
                                lpstring_t string_out, dword_t string_size) {
   strncpy(string_out, "666.666.666.666", string_size);
 }
-DECLARE_XAM_EXPORT(NetDll_XNetInAddrToString,
-                   ExportTag::kNetworking | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(NetDll_XNetInAddrToString, kNetworking, kStub);
 
 // This converts a XNet address to an IN_ADDR. The IN_ADDR is used for
 // subsequent socket calls (like a handle to a XNet address)
@@ -488,8 +472,7 @@ dword_result_t NetDll_XNetXnAddrToInAddr(dword_t caller,
                                          lpvoid_t xid, lpvoid_t in_addr) {
   return 1;
 }
-DECLARE_XAM_EXPORT(NetDll_XNetXnAddrToInAddr,
-                   ExportTag::kNetworking | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(NetDll_XNetXnAddrToInAddr, kNetworking, kStub);
 
 // Does the reverse of the above.
 // FIXME: Arguments may not be correct.
@@ -498,16 +481,14 @@ dword_result_t NetDll_XNetInAddrToXnAddr(dword_t caller, lpvoid_t in_addr,
                                          lpvoid_t xid) {
   return 1;
 }
-DECLARE_XAM_EXPORT(NetDll_XNetInAddrToXnAddr,
-                   ExportTag::kNetworking | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(NetDll_XNetInAddrToXnAddr, kNetworking, kStub);
 
-// http://www.google.com/patents/WO2008112448A1?cl=en
+// https://www.google.com/patents/WO2008112448A1?cl=en
 // Reserves a port for use by system link
 dword_result_t NetDll_XNetSetSystemLinkPort(dword_t caller, dword_t port) {
   return 1;
 }
-DECLARE_XAM_EXPORT(NetDll_XNetSetSystemLinkPort,
-                   ExportTag::kNetworking | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(NetDll_XNetSetSystemLinkPort, kNetworking, kStub);
 
 // https://github.com/ILOVEPIE/Cxbx-Reloaded/blob/master/src/CxbxKrnl/EmuXOnline.h#L39
 struct XEthernetStatus {
@@ -519,8 +500,7 @@ struct XEthernetStatus {
 };
 
 dword_result_t NetDll_XNetGetEthernetLinkStatus(dword_t caller) { return 0; }
-DECLARE_XAM_EXPORT(NetDll_XNetGetEthernetLinkStatus,
-                   ExportTag::kStub | ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_XNetGetEthernetLinkStatus, kNetworking, kStub);
 
 dword_result_t NetDll_XNetDnsLookup(dword_t caller, lpstring_t host,
                                     dword_t event_handle, lpdword_t pdns) {
@@ -539,8 +519,7 @@ dword_result_t NetDll_XNetDnsLookup(dword_t caller, lpstring_t host,
   }
   return 0;
 }
-DECLARE_XAM_EXPORT(NetDll_XNetDnsLookup,
-                   ExportTag::kStub | ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_XNetDnsLookup, kNetworking, kStub);
 
 dword_result_t NetDll_XNetDnsRelease(dword_t caller, pointer_t<XNDNS> dns) {
   if (!dns) {
@@ -549,8 +528,7 @@ dword_result_t NetDll_XNetDnsRelease(dword_t caller, pointer_t<XNDNS> dns) {
   kernel_memory()->SystemHeapFree(dns.guest_address());
   return 0;
 }
-DECLARE_XAM_EXPORT(NetDll_XNetDnsRelease,
-                   ExportTag::kStub | ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_XNetDnsRelease, kNetworking, kStub);
 
 SHIM_CALL NetDll_XNetQosServiceLookup_shim(PPCContext* ppc_context,
                                            KernelState* kernel_state) {
@@ -571,15 +549,13 @@ dword_result_t NetDll_XNetQosListen(dword_t caller, lpvoid_t id, lpvoid_t data,
                                     dword_t flags) {
   return X_ERROR_FUNCTION_FAILED;
 }
-DECLARE_XAM_EXPORT(NetDll_XNetQosListen,
-                   ExportTag::kStub | ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_XNetQosListen, kNetworking, kStub);
 
 dword_result_t NetDll_inet_addr(lpstring_t addr_ptr) {
   uint32_t addr = inet_addr(addr_ptr);
   return xe::byte_swap(addr);
 }
-DECLARE_XAM_EXPORT(NetDll_inet_addr,
-                   ExportTag::kImplemented | ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_inet_addr, kNetworking, kImplemented);
 
 dword_result_t NetDll_socket(dword_t caller, dword_t af, dword_t type,
                              dword_t protocol) {
@@ -591,15 +567,14 @@ dword_result_t NetDll_socket(dword_t caller, dword_t af, dword_t type,
   if (XFAILED(result)) {
     socket->Release();
 
-    uint32_t error = xboxkrnl::RtlNtStatusToDosError(result);
+    uint32_t error = xboxkrnl::xeRtlNtStatusToDosError(result);
     XThread::SetLastError(error);
     return -1;
   }
 
   return socket->handle();
 }
-DECLARE_XAM_EXPORT(NetDll_socket,
-                   ExportTag::kImplemented | ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_socket, kNetworking, kImplemented);
 
 dword_result_t NetDll_closesocket(dword_t caller, dword_t socket_handle) {
   auto socket =
@@ -616,8 +591,7 @@ dword_result_t NetDll_closesocket(dword_t caller, dword_t socket_handle) {
   socket->ReleaseHandle();
   return 0;
 }
-DECLARE_XAM_EXPORT(NetDll_closesocket,
-                   ExportTag::kImplemented | ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_closesocket, kNetworking, kImplemented);
 
 int_result_t NetDll_shutdown(dword_t caller, dword_t socket_handle, int_t how) {
   auto socket =
@@ -639,8 +613,7 @@ int_result_t NetDll_shutdown(dword_t caller, dword_t socket_handle, int_t how) {
   }
   return ret;
 }
-DECLARE_XAM_EXPORT(NetDll_shutdown,
-                   ExportTag::kImplemented | ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_shutdown, kNetworking, kImplemented);
 
 dword_result_t NetDll_setsockopt(dword_t caller, dword_t socket_handle,
                                  dword_t level, dword_t optname,
@@ -656,8 +629,7 @@ dword_result_t NetDll_setsockopt(dword_t caller, dword_t socket_handle,
   X_STATUS status = socket->SetOption(level, optname, optval_ptr, optlen);
   return XSUCCEEDED(status) ? 0 : -1;
 }
-DECLARE_XAM_EXPORT(NetDll_setsockopt,
-                   ExportTag::kImplemented | ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_setsockopt, kNetworking, kImplemented);
 
 dword_result_t NetDll_ioctlsocket(dword_t caller, dword_t socket_handle,
                                   dword_t cmd, lpvoid_t arg_ptr) {
@@ -671,15 +643,14 @@ dword_result_t NetDll_ioctlsocket(dword_t caller, dword_t socket_handle,
 
   X_STATUS status = socket->IOControl(cmd, arg_ptr);
   if (XFAILED(status)) {
-    XThread::SetLastError(xboxkrnl::RtlNtStatusToDosError(status));
+    XThread::SetLastError(xboxkrnl::xeRtlNtStatusToDosError(status));
     return -1;
   }
 
   // TODO
   return 0;
 }
-DECLARE_XAM_EXPORT(NetDll_ioctlsocket,
-                   ExportTag::kImplemented | ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_ioctlsocket, kNetworking, kImplemented);
 
 dword_result_t NetDll_bind(dword_t caller, dword_t socket_handle,
                            pointer_t<XSOCKADDR_IN> name, dword_t namelen) {
@@ -694,14 +665,13 @@ dword_result_t NetDll_bind(dword_t caller, dword_t socket_handle,
   N_XSOCKADDR_IN native_name(name);
   X_STATUS status = socket->Bind(&native_name, namelen);
   if (XFAILED(status)) {
-    XThread::SetLastError(xboxkrnl::RtlNtStatusToDosError(status));
+    XThread::SetLastError(xboxkrnl::xeRtlNtStatusToDosError(status));
     return -1;
   }
 
   return 0;
 }
-DECLARE_XAM_EXPORT(NetDll_bind,
-                   ExportTag::kImplemented | ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_bind, kNetworking, kImplemented);
 
 dword_result_t NetDll_connect(dword_t caller, dword_t socket_handle,
                               pointer_t<XSOCKADDR> name, dword_t namelen) {
@@ -716,14 +686,13 @@ dword_result_t NetDll_connect(dword_t caller, dword_t socket_handle,
   N_XSOCKADDR native_name(name);
   X_STATUS status = socket->Connect(&native_name, namelen);
   if (XFAILED(status)) {
-    XThread::SetLastError(xboxkrnl::RtlNtStatusToDosError(status));
+    XThread::SetLastError(xboxkrnl::xeRtlNtStatusToDosError(status));
     return -1;
   }
 
   return 0;
 }
-DECLARE_XAM_EXPORT(NetDll_connect,
-                   ExportTag::kImplemented | ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_connect, kNetworking, kImplemented);
 
 dword_result_t NetDll_listen(dword_t caller, dword_t socket_handle,
                              int_t backlog) {
@@ -737,14 +706,13 @@ dword_result_t NetDll_listen(dword_t caller, dword_t socket_handle,
 
   X_STATUS status = socket->Listen(backlog);
   if (XFAILED(status)) {
-    XThread::SetLastError(xboxkrnl::RtlNtStatusToDosError(status));
+    XThread::SetLastError(xboxkrnl::xeRtlNtStatusToDosError(status));
     return -1;
   }
 
   return 0;
 }
-DECLARE_XAM_EXPORT(NetDll_listen,
-                   ExportTag::kImplemented | ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_listen, kNetworking, kImplemented);
 
 dword_result_t NetDll_accept(dword_t caller, dword_t socket_handle,
                              pointer_t<XSOCKADDR> addr_ptr,
@@ -776,8 +744,7 @@ dword_result_t NetDll_accept(dword_t caller, dword_t socket_handle,
     return -1;
   }
 }
-DECLARE_XAM_EXPORT(NetDll_accept,
-                   ExportTag::kImplemented | ExportTag::kNetworking);
+DECLARE_XAM_EXPORT1(NetDll_accept, kNetworking, kImplemented);
 
 struct x_fd_set {
   xe::be<uint32_t> fd_count;
@@ -884,8 +851,7 @@ int_result_t NetDll_select(int_t caller, int_t nfds,
   // TODO(gibbed): modify ret to be what's actually copied to the guest fd_sets?
   return ret;
 }
-DECLARE_XAM_EXPORT(NetDll_select,
-                   ExportTag::kNetworking | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(NetDll_select, kNetworking, kImplemented);
 
 dword_result_t NetDll_recv(dword_t caller, dword_t socket_handle,
                            lpvoid_t buf_ptr, dword_t buf_len, dword_t flags) {
@@ -899,8 +865,7 @@ dword_result_t NetDll_recv(dword_t caller, dword_t socket_handle,
 
   return socket->Recv(buf_ptr, buf_len, flags);
 }
-DECLARE_XAM_EXPORT(NetDll_recv,
-                   ExportTag::kNetworking | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(NetDll_recv, kNetworking, kImplemented);
 
 dword_result_t NetDll_recvfrom(dword_t caller, dword_t socket_handle,
                                lpvoid_t buf_ptr, dword_t buf_len, dword_t flags,
@@ -944,8 +909,7 @@ dword_result_t NetDll_recvfrom(dword_t caller, dword_t socket_handle,
 
   return ret;
 }
-DECLARE_XAM_EXPORT(NetDll_recvfrom,
-                   ExportTag::kNetworking | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(NetDll_recvfrom, kNetworking, kImplemented);
 
 dword_result_t NetDll_send(dword_t caller, dword_t socket_handle,
                            lpvoid_t buf_ptr, dword_t buf_len, dword_t flags) {
@@ -959,8 +923,7 @@ dword_result_t NetDll_send(dword_t caller, dword_t socket_handle,
 
   return socket->Send(buf_ptr, buf_len, flags);
 }
-DECLARE_XAM_EXPORT(NetDll_send,
-                   ExportTag::kNetworking | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(NetDll_send, kNetworking, kImplemented);
 
 dword_result_t NetDll_sendto(dword_t caller, dword_t socket_handle,
                              lpvoid_t buf_ptr, dword_t buf_len, dword_t flags,
@@ -976,8 +939,7 @@ dword_result_t NetDll_sendto(dword_t caller, dword_t socket_handle,
   N_XSOCKADDR_IN native_to(to_ptr);
   return socket->SendTo(buf_ptr, buf_len, flags, &native_to, to_len);
 }
-DECLARE_XAM_EXPORT(NetDll_sendto,
-                   ExportTag::kNetworking | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(NetDll_sendto, kNetworking, kImplemented);
 
 void RegisterNetExports(xe::cpu::ExportResolver* export_resolver,
                         KernelState* kernel_state) {
diff --git a/src/xenia/kernel/xam/xam_notify.cc b/src/xenia/kernel/xam/xam_notify.cc
index fa31ca930..e3765af25 100644
--- a/src/xenia/kernel/xam/xam_notify.cc
+++ b/src/xenia/kernel/xam/xam_notify.cc
@@ -18,7 +18,8 @@ namespace xe {
 namespace kernel {
 namespace xam {
 
-dword_result_t XamNotifyCreateListener(qword_t mask, dword_t one) {
+dword_result_t XamNotifyCreateListenerInternal(qword_t mask, dword_t unk,
+                                               dword_t one) {
   // r4=1 may indicate user process?
 
   auto listener =
@@ -30,9 +31,15 @@ dword_result_t XamNotifyCreateListener(qword_t mask, dword_t one) {
 
   return handle;
 }
-DECLARE_XAM_EXPORT(XamNotifyCreateListener, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT2(XamNotifyCreateListenerInternal, kNone, kImplemented,
+                    kSketchy);
 
-// http://ffplay360.googlecode.com/svn/Test/Common/AtgSignIn.cpp
+dword_result_t XamNotifyCreateListener(qword_t mask, dword_t one) {
+  return XamNotifyCreateListenerInternal(mask, 0, one);
+}
+DECLARE_XAM_EXPORT1(XamNotifyCreateListener, kNone, kImplemented);
+
+// https://github.com/CodeAsm/ffplay360/blob/master/Common/AtgSignIn.cpp
 dword_result_t XNotifyGetNext(dword_t handle, dword_t match_id,
                               lpdword_t id_ptr, lpdword_t param_ptr) {
   if (!handle) {
@@ -68,19 +75,18 @@ dword_result_t XNotifyGetNext(dword_t handle, dword_t match_id,
 
   return dequeued ? 1 : 0;
 }
-DECLARE_XAM_EXPORT(XNotifyGetNext,
-                   ExportTag::kImplemented | ExportTag::kHighFrequency);
+DECLARE_XAM_EXPORT2(XNotifyGetNext, kNone, kImplemented, kHighFrequency);
 
 dword_result_t XNotifyDelayUI(dword_t delay_ms) {
   // Ignored.
   return 0;
 }
-DECLARE_XAM_EXPORT(XNotifyDelayUI, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XNotifyDelayUI, kNone, kStub);
 
 void XNotifyPositionUI(dword_t position) {
   // Ignored.
 }
-DECLARE_XAM_EXPORT(XNotifyPositionUI, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XNotifyPositionUI, kNone, kStub);
 
 void RegisterNotifyExports(xe::cpu::ExportResolver* export_resolver,
                            KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xam/xam_nui.cc b/src/xenia/kernel/xam/xam_nui.cc
index f8655d7ee..1327bef3d 100644
--- a/src/xenia/kernel/xam/xam_nui.cc
+++ b/src/xenia/kernel/xam/xam_nui.cc
@@ -36,7 +36,7 @@ void XamNuiGetDeviceStatus(pointer_t<X_NUI_DEVICE_STATUS> status_ptr) {
   status_ptr.Zero();
   status_ptr->status = 0;  // Not connected.
 }
-DECLARE_XAM_EXPORT(XamNuiGetDeviceStatus, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamNuiGetDeviceStatus, kNone, kStub);
 
 dword_result_t XamShowNuiTroubleshooterUI(unknown_t unk1, unknown_t unk2,
                                           unknown_t unk3) {
@@ -61,7 +61,7 @@ dword_result_t XamShowNuiTroubleshooterUI(unknown_t unk1, unknown_t unk2,
 
   return 0;
 }
-DECLARE_XAM_EXPORT(XamShowNuiTroubleshooterUI, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamShowNuiTroubleshooterUI, kNone, kStub);
 
 void RegisterNuiExports(xe::cpu::ExportResolver* export_resolver,
                         KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xam/xam_table.inc b/src/xenia/kernel/xam/xam_table.inc
index cec253c69..0bc4f02e6 100644
--- a/src/xenia/kernel/xam/xam_table.inc
+++ b/src/xenia/kernel/xam/xam_table.inc
@@ -588,7 +588,7 @@ XE_EXPORT(xam,      0x00000318, XamVoiceGetMicArrayStatus,
 XE_EXPORT(xam,      0x00000319, XamVoiceSetAudioCaptureRoutine,                             kFunction),
 XE_EXPORT(xam,      0x0000031A, XamVoiceGetDirectionalData,                                 kFunction),
 XE_EXPORT(xam,      0x0000031B, XamBuildResourceLocator,                                    kFunction),
-XE_EXPORT(xam,      0x0000031C, XamBuildSharedSystemResourceLocator_,                       kFunction),
+XE_EXPORT(xam,      0x0000031C, XamBuildLegacySystemResourceLocator,                        kFunction),
 XE_EXPORT(xam,      0x0000031D, XamBuildGamercardResourceLocator,                           kFunction),
 XE_EXPORT(xam,      0x0000031E, XamBuildDynamicResourceLocator,                             kFunction),
 XE_EXPORT(xam,      0x0000031F, XamBuildXamResourceLocator,                                 kFunction),
diff --git a/src/xenia/kernel/xam/xam_ui.cc b/src/xenia/kernel/xam/xam_ui.cc
index a8dd37d38..4ada0d77e 100644
--- a/src/xenia/kernel/xam/xam_ui.cc
+++ b/src/xenia/kernel/xam/xam_ui.cc
@@ -23,11 +23,8 @@ namespace xam {
 
 std::atomic<int> xam_dialogs_shown_ = {0};
 
-SHIM_CALL XamIsUIActive_shim(PPCContext* ppc_context,
-                             KernelState* kernel_state) {
-  XELOGD("XamIsUIActive()");
-  SHIM_SET_RETURN_32(xam_dialogs_shown_ > 0 ? 1 : 0);
-}
+dword_result_t XamIsUIActive() { return xam_dialogs_shown_ > 0 ? 1 : 0; }
+DECLARE_XAM_EXPORT2(XamIsUIActive, kUI, kImplemented, kHighFrequency);
 
 class MessageBoxDialog : public xe::ui::ImGuiDialog {
  public:
@@ -86,31 +83,26 @@ class MessageBoxDialog : public xe::ui::ImGuiDialog {
   uint32_t* out_chosen_button_ = nullptr;
 };
 
-// http://www.se7ensins.com/forums/threads/working-xshowmessageboxui.844116/?jdfwkey=sb0vm
-SHIM_CALL XamShowMessageBoxUI_shim(PPCContext* ppc_context,
-                                   KernelState* kernel_state) {
-  uint32_t user_index = SHIM_GET_ARG_32(0);
-  uint32_t title_ptr = SHIM_GET_ARG_32(1);
-  uint32_t text_ptr = SHIM_GET_ARG_32(2);
-  uint32_t button_count = SHIM_GET_ARG_32(3);
-  uint32_t button_ptrs = SHIM_GET_ARG_32(4);
-  uint32_t active_button = SHIM_GET_ARG_32(5);
-  uint32_t flags = SHIM_GET_ARG_32(6);
-  uint32_t result_ptr = SHIM_GET_ARG_32(7);
-  uint32_t overlapped_ptr = SHIM_GET_ARG_32(8);
-
+// https://www.se7ensins.com/forums/threads/working-xshowmessageboxui.844116/
+dword_result_t XamShowMessageBoxUI(dword_t user_index, lpwstring_t title_ptr,
+                                   lpwstring_t text_ptr, dword_t button_count,
+                                   lpdword_t button_ptrs, dword_t active_button,
+                                   dword_t flags, lpdword_t result_ptr,
+                                   pointer_t<XAM_OVERLAPPED> overlapped) {
   std::wstring title;
   if (title_ptr) {
-    title = xe::load_and_swap<std::wstring>(SHIM_MEM_ADDR(title_ptr));
+    title = title_ptr.value();
   } else {
     title = L"";  // TODO(gibbed): default title based on flags?
   }
-  auto text = xe::load_and_swap<std::wstring>(SHIM_MEM_ADDR(text_ptr));
+  auto text = text_ptr.value();
+
   std::vector<std::wstring> buttons;
   std::wstring all_buttons;
   for (uint32_t j = 0; j < button_count; ++j) {
-    uint32_t button_ptr = SHIM_MEM_32(button_ptrs + j * 4);
-    auto button = xe::load_and_swap<std::wstring>(SHIM_MEM_ADDR(button_ptr));
+    uint32_t button_ptr = button_ptrs[j];
+    auto button = xe::load_and_swap<std::wstring>(
+        kernel_state()->memory()->TranslateVirtual(button_ptr));
     all_buttons.append(button);
     if (j + 1 < button_count) {
       all_buttons.append(L" | ");
@@ -118,19 +110,12 @@ SHIM_CALL XamShowMessageBoxUI_shim(PPCContext* ppc_context,
     buttons.push_back(button);
   }
 
-  XELOGD(
-      "XamShowMessageBoxUI(%d, %.8X(%S), %.8X(%S), %d, %.8X(%S), %d, %X, %.8X, "
-      "%.8X)",
-      user_index, title_ptr, title.c_str(), text_ptr, text.c_str(),
-      button_count, button_ptrs, all_buttons.c_str(), active_button, flags,
-      result_ptr, overlapped_ptr);
-
   uint32_t chosen_button;
   if (FLAGS_headless) {
     // Auto-pick the focused button.
     chosen_button = active_button;
   } else {
-    auto display_window = kernel_state->emulator()->display_window();
+    auto display_window = kernel_state()->emulator()->display_window();
     xe::threading::Fence fence;
     display_window->loop()->PostSynchronous([&]() {
       // TODO(benvanik): setup icon states.
@@ -156,11 +141,16 @@ SHIM_CALL XamShowMessageBoxUI_shim(PPCContext* ppc_context,
     fence.Wait();
     --xam_dialogs_shown_;
   }
-  SHIM_SET_MEM_32(result_ptr, chosen_button);
+  *result_ptr = chosen_button;
 
-  kernel_state->CompleteOverlappedImmediate(overlapped_ptr, X_ERROR_SUCCESS);
-  SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
+  if (overlapped) {
+    kernel_state()->CompleteOverlappedImmediate(overlapped, X_ERROR_SUCCESS);
+    return X_ERROR_IO_PENDING;
+  } else {
+    return X_ERROR_SUCCESS;
+  }
 }
+DECLARE_XAM_EXPORT1(XamShowMessageBoxUI, kUI, kImplemented);
 
 class KeyboardInputDialog : public xe::ui::ImGuiDialog {
  public:
@@ -231,7 +221,7 @@ class KeyboardInputDialog : public xe::ui::ImGuiDialog {
   size_t max_length_ = 0;
 };
 
-// http://www.se7ensins.com/forums/threads/release-how-to-use-xshowkeyboardui-release.906568/
+// https://www.se7ensins.com/forums/threads/release-how-to-use-xshowkeyboardui-release.906568/
 dword_result_t XamShowKeyboardUI(dword_t user_index, dword_t flags,
                                  lpwstring_t default_text, lpwstring_t title,
                                  lpwstring_t description, lpwstring_t buffer,
@@ -285,7 +275,7 @@ dword_result_t XamShowKeyboardUI(dword_t user_index, dword_t flags,
     return X_ERROR_SUCCESS;
   }
 }
-DECLARE_XAM_EXPORT(XamShowKeyboardUI, ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamShowKeyboardUI, kUI, kImplemented);
 
 dword_result_t XamShowDeviceSelectorUI(dword_t user_index, dword_t content_type,
                                        dword_t content_flags,
@@ -316,21 +306,16 @@ dword_result_t XamShowDeviceSelectorUI(dword_t user_index, dword_t content_type,
     return X_ERROR_SUCCESS;
   }
 }
-DECLARE_XAM_EXPORT(XamShowDeviceSelectorUI, ExportTag::kImplemented);
-
-SHIM_CALL XamShowDirtyDiscErrorUI_shim(PPCContext* ppc_context,
-                                       KernelState* kernel_state) {
-  uint32_t user_index = SHIM_GET_ARG_32(0);
-
-  XELOGD("XamShowDirtyDiscErrorUI(%d)", user_index);
+DECLARE_XAM_EXPORT1(XamShowDeviceSelectorUI, kUI, kImplemented);
 
+void XamShowDirtyDiscErrorUI(dword_t user_index) {
   if (FLAGS_headless) {
     assert_always();
     exit(1);
     return;
   }
 
-  auto display_window = kernel_state->emulator()->display_window();
+  auto display_window = kernel_state()->emulator()->display_window();
   xe::threading::Fence fence;
   display_window->loop()->PostSynchronous([&]() {
     xe::ui::ImGuiDialog::ShowMessageBox(
@@ -347,13 +332,10 @@ SHIM_CALL XamShowDirtyDiscErrorUI_shim(PPCContext* ppc_context,
   // TODO(benvanik): cleaner exit.
   exit(1);
 }
+DECLARE_XAM_EXPORT1(XamShowDirtyDiscErrorUI, kUI, kImplemented);
 
 void RegisterUIExports(xe::cpu::ExportResolver* export_resolver,
-                       KernelState* kernel_state) {
-  SHIM_SET_MAPPING("xam.xex", XamIsUIActive, state);
-  SHIM_SET_MAPPING("xam.xex", XamShowMessageBoxUI, state);
-  SHIM_SET_MAPPING("xam.xex", XamShowDirtyDiscErrorUI, state);
-}
+                       KernelState* kernel_state) {}
 
 }  // namespace xam
 }  // namespace kernel
diff --git a/src/xenia/kernel/xam/xam_user.cc b/src/xenia/kernel/xam/xam_user.cc
index 4a15d3662..03b72ebcd 100644
--- a/src/xenia/kernel/xam/xam_user.cc
+++ b/src/xenia/kernel/xam/xam_user.cc
@@ -32,8 +32,7 @@ X_HRESULT_result_t XamUserGetXUID(dword_t user_index, dword_t unk,
   }
   return X_E_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamUserGetXUID,
-                   ExportTag::kUserProfiles | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamUserGetXUID, kUserProfiles, kImplemented);
 
 dword_result_t XamUserGetSigninState(dword_t user_index) {
   // Yield, as some games spam this.
@@ -50,8 +49,8 @@ dword_result_t XamUserGetSigninState(dword_t user_index) {
     return 0;
   }
 }
-DECLARE_XAM_EXPORT(XamUserGetSigninState,
-                   ExportTag::kUserProfiles | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT2(XamUserGetSigninState, kUserProfiles, kImplemented,
+                    kHighFrequency);
 
 typedef struct {
   xe::be<uint64_t> xuid;
@@ -80,8 +79,7 @@ X_HRESULT_result_t XamUserGetSigninInfo(dword_t user_index, dword_t flags,
   std::strncpy(info->name, user_profile->name().data(), 15);
   return X_E_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamUserGetSigninInfo,
-                   ExportTag::kUserProfiles | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamUserGetSigninInfo, kUserProfiles, kImplemented);
 
 dword_result_t XamUserGetName(dword_t user_index, lpstring_t buffer,
                               dword_t buffer_len) {
@@ -92,8 +90,7 @@ dword_result_t XamUserGetName(dword_t user_index, lpstring_t buffer,
   std::strncpy(buffer, user_profile->name().data(), buffer_len);
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamUserGetName,
-                   ExportTag::kUserProfiles | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamUserGetName, kUserProfiles, kImplemented);
 
 typedef struct {
   xe::be<uint32_t> setting_count;
@@ -112,7 +109,7 @@ typedef struct {
 } X_USER_READ_PROFILE_SETTING;
 static_assert_size(X_USER_READ_PROFILE_SETTING, 40);
 
-// http://freestyledash.googlecode.com/svn/trunk/Freestyle/Tools/Generic/xboxtools.cpp
+// https://github.com/oukiar/freestyledash/blob/master/Freestyle/Tools/Generic/xboxtools.cpp
 dword_result_t XamUserReadProfileSettings(
     dword_t title_id, dword_t user_index, dword_t unk_0, dword_t unk_1,
     dword_t setting_count, lpdword_t setting_ids, lpdword_t buffer_size_ptr,
@@ -227,8 +224,7 @@ dword_result_t XamUserReadProfileSettings(
   }
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamUserReadProfileSettings,
-                   ExportTag::kUserProfiles | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamUserReadProfileSettings, kUserProfiles, kImplemented);
 
 typedef struct {
   xe::be<uint32_t> from;
@@ -290,6 +286,7 @@ dword_result_t XamUserWriteProfileSettings(
         static_cast<xam::UserProfile::Setting::Type>(settings_data.type);
 
     switch (settingType) {
+      case UserProfile::Setting::Type::CONTENT:
       case UserProfile::Setting::Type::BINARY: {
         uint8_t* settings_data_ptr = kernel_state()->memory()->TranslateVirtual(
             settings_data.binary.ptr);
@@ -332,8 +329,7 @@ dword_result_t XamUserWriteProfileSettings(
   }
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamUserWriteProfileSettings,
-                   ExportTag::kUserProfiles | ExportTag::kImplemented);
+DECLARE_XAM_EXPORT1(XamUserWriteProfileSettings, kUserProfiles, kImplemented);
 
 dword_result_t XamUserCheckPrivilege(dword_t user_index, dword_t mask,
                                      lpdword_t out_value) {
@@ -351,8 +347,7 @@ dword_result_t XamUserCheckPrivilege(dword_t user_index, dword_t mask,
   *out_value = 0;
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamUserCheckPrivilege,
-                   ExportTag::kUserProfiles | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamUserCheckPrivilege, kUserProfiles, kStub);
 
 dword_result_t XamUserContentRestrictionGetFlags(dword_t user_index,
                                                  lpdword_t out_flags) {
@@ -370,8 +365,7 @@ dword_result_t XamUserContentRestrictionGetFlags(dword_t user_index,
   *out_flags = 0;
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamUserContentRestrictionGetFlags,
-                   ExportTag::kUserProfiles | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamUserContentRestrictionGetFlags, kUserProfiles, kStub);
 
 dword_result_t XamUserContentRestrictionGetRating(dword_t user_index,
                                                   dword_t unk1,
@@ -393,8 +387,7 @@ dword_result_t XamUserContentRestrictionGetRating(dword_t user_index,
   *out_unk3 = 0;
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamUserContentRestrictionGetRating,
-                   ExportTag::kUserProfiles | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamUserContentRestrictionGetRating, kUserProfiles, kStub);
 
 dword_result_t XamUserContentRestrictionCheckAccess(dword_t user_index,
                                                     dword_t unk1, dword_t unk2,
@@ -411,8 +404,7 @@ dword_result_t XamUserContentRestrictionCheckAccess(dword_t user_index,
 
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamUserContentRestrictionCheckAccess,
-                   ExportTag::kUserProfiles | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamUserContentRestrictionCheckAccess, kUserProfiles, kStub);
 
 dword_result_t XamUserAreUsersFriends(dword_t user_index, dword_t unk1,
                                       dword_t unk2, lpdword_t out_value,
@@ -446,8 +438,7 @@ dword_result_t XamUserAreUsersFriends(dword_t user_index, dword_t unk1,
   }
   return result;
 }
-DECLARE_XAM_EXPORT(XamUserAreUsersFriends,
-                   ExportTag::kUserProfiles | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamUserAreUsersFriends, kUserProfiles, kStub);
 
 dword_result_t XamShowSigninUI(dword_t unk, dword_t unk_mask) {
   // Mask values vary. Probably matching user types? Local/remote?
@@ -455,8 +446,7 @@ dword_result_t XamShowSigninUI(dword_t unk, dword_t unk_mask) {
   kernel_state()->BroadcastNotification(0x00000009, 0);
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamShowSigninUI,
-                   ExportTag::kUserProfiles | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamShowSigninUI, kUserProfiles, kStub);
 
 dword_result_t XamUserCreateAchievementEnumerator(dword_t title_id,
                                                   dword_t user_index,
@@ -465,19 +455,18 @@ dword_result_t XamUserCreateAchievementEnumerator(dword_t title_id,
                                                   lpdword_t buffer_size_ptr,
                                                   lpdword_t handle_ptr) {
   if (buffer_size_ptr) {
-    // TODO(benvanik): struct size/etc.
-    *buffer_size_ptr = 64 * count;
+    *buffer_size_ptr = 500 * count;
   }
 
-  auto e = new XStaticEnumerator(kernel_state(), count, 64);
+  auto e = new XStaticEnumerator(kernel_state(), count, 500);
   e->Initialize();
 
   *handle_ptr = e->handle();
 
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamUserCreateAchievementEnumerator,
-                   ExportTag::kUserProfiles | ExportTag::kSketchy);
+DECLARE_XAM_EXPORT1(XamUserCreateAchievementEnumerator, kUserProfiles,
+                    kSketchy);
 
 dword_result_t XamParseGamerTileKey(lpdword_t key_ptr, lpdword_t out1_ptr,
                                     lpdword_t out2_ptr, lpdword_t out3_ptr) {
@@ -486,8 +475,7 @@ dword_result_t XamParseGamerTileKey(lpdword_t key_ptr, lpdword_t out1_ptr,
   *out3_ptr = 0xC0DE0003;
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamParseGamerTileKey,
-                   ExportTag::kUserProfiles | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamParseGamerTileKey, kUserProfiles, kStub);
 
 dword_result_t XamReadTileToTexture(dword_t unk1, dword_t unk2, dword_t unk3,
                                     dword_t unk4, lpvoid_t buffer_ptr,
@@ -505,8 +493,7 @@ dword_result_t XamReadTileToTexture(dword_t unk1, dword_t unk2, dword_t unk3,
   }
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamReadTileToTexture,
-                   ExportTag::kUserProfiles | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamReadTileToTexture, kUserProfiles, kStub);
 
 dword_result_t XamWriteGamerTile(dword_t arg1, dword_t arg2, dword_t arg3,
                                  dword_t arg4, dword_t arg5,
@@ -518,23 +505,20 @@ dword_result_t XamWriteGamerTile(dword_t arg1, dword_t arg2, dword_t arg3,
   }
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamWriteGamerTile,
-                   ExportTag::kUserProfiles | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamWriteGamerTile, kUserProfiles, kStub);
 
 dword_result_t XamSessionCreateHandle(lpdword_t handle_ptr) {
   *handle_ptr = 0xCAFEDEAD;
   return X_ERROR_SUCCESS;
 }
-DECLARE_XAM_EXPORT(XamSessionCreateHandle,
-                   ExportTag::kUserProfiles | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamSessionCreateHandle, kUserProfiles, kStub);
 
 dword_result_t XamSessionRefObjByHandle(dword_t handle, lpdword_t obj_ptr) {
   assert_true(handle == 0xCAFEDEAD);
   *obj_ptr = 0;
   return X_ERROR_FUNCTION_FAILED;
 }
-DECLARE_XAM_EXPORT(XamSessionRefObjByHandle,
-                   ExportTag::kUserProfiles | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamSessionRefObjByHandle, kUserProfiles, kStub);
 
 }  // namespace xam
 }  // namespace kernel
diff --git a/src/xenia/kernel/xam/xam_video.cc b/src/xenia/kernel/xam/xam_video.cc
index 157af39fd..8cdf63869 100644
--- a/src/xenia/kernel/xam/xam_video.cc
+++ b/src/xenia/kernel/xam/xam_video.cc
@@ -22,10 +22,10 @@ void XGetVideoMode(pointer_t<X_VIDEO_MODE> video_mode) {
   // TODO(benvanik): actually check to see if these are the same.
   xboxkrnl::VdQueryVideoMode(std::move(video_mode));
 }
-DECLARE_XAM_EXPORT(XGetVideoMode, ExportTag::kVideo | ExportTag::kSketchy);
+DECLARE_XAM_EXPORT1(XGetVideoMode, kVideo, ExportTag::kSketchy);
 
 dword_result_t XGetVideoCapabilities() { return 0; }
-DECLARE_XAM_EXPORT(XGetVideoCapabilities, ExportTag::kVideo | ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XGetVideoCapabilities, kVideo, kStub);
 
 void RegisterVideoExports(xe::cpu::ExportResolver* export_resolver,
                           KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xam/xam_voice.cc b/src/xenia/kernel/xam/xam_voice.cc
index 96de3db66..2cd70b2ca 100644
--- a/src/xenia/kernel/xam/xam_voice.cc
+++ b/src/xenia/kernel/xam/xam_voice.cc
@@ -21,7 +21,7 @@ dword_result_t XamVoiceIsActiveProcess() {
   // Returning 0 here will short-circuit a bunch of voice stuff.
   return 0;
 }
-DECLARE_XAM_EXPORT(XamVoiceIsActiveProcess, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamVoiceIsActiveProcess, kNone, kStub);
 
 dword_result_t XamVoiceCreate(unknown_t unk1,  // 0
                               unknown_t unk2,  // 0xF
@@ -30,13 +30,13 @@ dword_result_t XamVoiceCreate(unknown_t unk1,  // 0
   out_voice_ptr.Zero();
   return X_ERROR_ACCESS_DENIED;
 }
-DECLARE_XAM_EXPORT(XamVoiceCreate, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamVoiceCreate, kNone, kStub);
 
 dword_result_t XamVoiceClose(lpunknown_t voice_ptr) { return 0; }
-DECLARE_XAM_EXPORT(XamVoiceClose, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamVoiceClose, kNone, kStub);
 
 dword_result_t XamVoiceHeadsetPresent(lpunknown_t voice_ptr) { return 0; }
-DECLARE_XAM_EXPORT(XamVoiceHeadsetPresent, ExportTag::kStub);
+DECLARE_XAM_EXPORT1(XamVoiceHeadsetPresent, kNone, kStub);
 
 void RegisterVoiceExports(xe::cpu::ExportResolver* export_resolver,
                           KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xbdm/xbdm_misc.cc b/src/xenia/kernel/xbdm/xbdm_misc.cc
index 2075a8c3c..53f3113d9 100644
--- a/src/xenia/kernel/xbdm/xbdm_misc.cc
+++ b/src/xenia/kernel/xbdm/xbdm_misc.cc
@@ -19,30 +19,28 @@ namespace kernel {
 namespace xbdm {
 
 void DmCloseLoadedModules(lpdword_t unk0_ptr) {}
-DECLARE_XBDM_EXPORT(DmCloseLoadedModules, ExportTag::kStub | ExportTag::kDebug);
+DECLARE_XBDM_EXPORT1(DmCloseLoadedModules, kDebug, kStub);
 
 void DmSendNotificationString(lpdword_t unk0_ptr) {}
-DECLARE_XBDM_EXPORT(DmSendNotificationString,
-                    ExportTag::kStub | ExportTag::kDebug);
+DECLARE_XBDM_EXPORT1(DmSendNotificationString, kDebug, kStub);
 
 dword_result_t DmWalkLoadedModules(lpdword_t unk0_ptr, lpdword_t unk1_ptr) {
   return X_STATUS_INVALID_PARAMETER;
 }
-DECLARE_XBDM_EXPORT(DmWalkLoadedModules, ExportTag::kStub | ExportTag::kDebug);
+DECLARE_XBDM_EXPORT1(DmWalkLoadedModules, kDebug, kStub);
 
 dword_result_t DmCaptureStackBackTrace(lpdword_t unk0_ptr, lpdword_t unk1_ptr) {
   return X_STATUS_INVALID_PARAMETER;
 }
-DECLARE_XBDM_EXPORT(DmCaptureStackBackTrace,
-                    ExportTag::kStub | ExportTag::kDebug);
+DECLARE_XBDM_EXPORT1(DmCaptureStackBackTrace, kDebug, kStub);
 
 void DmMapDevkitDrive() {}
-DECLARE_XBDM_EXPORT(DmMapDevkitDrive, ExportTag::kStub | ExportTag::kDebug);
+DECLARE_XBDM_EXPORT1(DmMapDevkitDrive, kDebug, kStub);
 
 dword_result_t DmFindPdbSignature(lpdword_t unk0_ptr, lpdword_t unk1_ptr) {
   return X_STATUS_INVALID_PARAMETER;
 }
-DECLARE_XBDM_EXPORT(DmFindPdbSignature, ExportTag::kStub | ExportTag::kDebug);
+DECLARE_XBDM_EXPORT1(DmFindPdbSignature, kDebug, kStub);
 
 void RegisterMiscExports(xe::cpu::ExportResolver* export_resolver,
                          KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_audio.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_audio.cc
index 1a8bafaa1..d9c861211 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_audio.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_audio.cc
@@ -23,8 +23,7 @@ dword_result_t XAudioGetSpeakerConfig(lpdword_t config_ptr) {
   *config_ptr = 0x00010001;
   return X_ERROR_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(XAudioGetSpeakerConfig,
-                        ExportTag::kImplemented | ExportTag::kAudio);
+DECLARE_XBOXKRNL_EXPORT1(XAudioGetSpeakerConfig, kAudio, kImplemented);
 
 dword_result_t XAudioGetVoiceCategoryVolumeChangeMask(lpunknown_t driver_ptr,
                                                       lpdword_t out_ptr) {
@@ -37,9 +36,8 @@ dword_result_t XAudioGetVoiceCategoryVolumeChangeMask(lpunknown_t driver_ptr,
   *out_ptr = 0;
   return X_ERROR_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(XAudioGetVoiceCategoryVolumeChangeMask,
-                        ExportTag::kStub | ExportTag::kAudio |
-                            ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XAudioGetVoiceCategoryVolumeChangeMask, kAudio, kStub,
+                         kHighFrequency);
 
 dword_result_t XAudioGetVoiceCategoryVolume(dword_t unk, lpfloat_t out_ptr) {
   // Expects a floating point single. Volume %?
@@ -47,12 +45,11 @@ dword_result_t XAudioGetVoiceCategoryVolume(dword_t unk, lpfloat_t out_ptr) {
 
   return X_ERROR_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(XAudioGetVoiceCategoryVolume,
-                        ExportTag::kStub | ExportTag::kAudio);
+DECLARE_XBOXKRNL_EXPORT2(XAudioGetVoiceCategoryVolume, kAudio, kStub,
+                         kHighFrequency);
 
 dword_result_t XAudioEnableDucker(dword_t unk) { return X_ERROR_SUCCESS; }
-DECLARE_XBOXKRNL_EXPORT(XAudioEnableDucker,
-                        ExportTag::kStub | ExportTag::kAudio);
+DECLARE_XBOXKRNL_EXPORT1(XAudioEnableDucker, kAudio, kStub);
 
 dword_result_t XAudioRegisterRenderDriverClient(lpdword_t callback_ptr,
                                                 lpdword_t driver_ptr) {
@@ -71,8 +68,8 @@ dword_result_t XAudioRegisterRenderDriverClient(lpdword_t callback_ptr,
   *driver_ptr = 0x41550000 | (static_cast<uint32_t>(index) & 0x0000FFFF);
   return X_ERROR_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(XAudioRegisterRenderDriverClient,
-                        ExportTag::kImplemented | ExportTag::kAudio);
+DECLARE_XBOXKRNL_EXPORT1(XAudioRegisterRenderDriverClient, kAudio,
+                         kImplemented);
 
 dword_result_t XAudioUnregisterRenderDriverClient(lpunknown_t driver_ptr) {
   assert_true((driver_ptr.guest_address() & 0xFFFF0000) == 0x41550000);
@@ -81,8 +78,8 @@ dword_result_t XAudioUnregisterRenderDriverClient(lpunknown_t driver_ptr) {
   audio_system->UnregisterClient(driver_ptr.guest_address() & 0x0000FFFF);
   return X_ERROR_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(XAudioUnregisterRenderDriverClient,
-                        ExportTag::kImplemented | ExportTag::kAudio);
+DECLARE_XBOXKRNL_EXPORT1(XAudioUnregisterRenderDriverClient, kAudio,
+                         kImplemented);
 
 dword_result_t XAudioSubmitRenderDriverFrame(lpunknown_t driver_ptr,
                                              lpunknown_t samples_ptr) {
@@ -94,9 +91,8 @@ dword_result_t XAudioSubmitRenderDriverFrame(lpunknown_t driver_ptr,
 
   return X_ERROR_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(XAudioSubmitRenderDriverFrame,
-                        ExportTag::kImplemented | ExportTag::kAudio |
-                            ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XAudioSubmitRenderDriverFrame, kAudio, kImplemented,
+                         kHighFrequency);
 
 void RegisterAudioExports(xe::cpu::ExportResolver* export_resolver,
                           KernelState* kernel_state) {
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_audio_xma.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_audio_xma.cc
index c312bd554..c27e2351b 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_audio_xma.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_audio_xma.cc
@@ -66,18 +66,16 @@ dword_result_t XMACreateContext(lpdword_t context_out_ptr) {
   }
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(XMACreateContext, ExportTag::kImplemented |
-                                              ExportTag::kAudio |
-                                              ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMACreateContext, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMAReleaseContext(lpvoid_t context_ptr) {
   auto xma_decoder = kernel_state()->emulator()->audio_system()->xma_decoder();
   xma_decoder->ReleaseContext(context_ptr);
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XMAReleaseContext, ExportTag::kImplemented |
-                                               ExportTag::kAudio |
-                                               ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMAReleaseContext, kAudio, kImplemented,
+                         kHighFrequency);
 
 void StoreXmaContextIndexedRegister(KernelState* kernel_state,
                                     uint32_t base_reg, uint32_t context_ptr) {
@@ -147,9 +145,8 @@ dword_result_t XMAInitializeContext(lpvoid_t context_ptr,
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XMAInitializeContext, ExportTag::kImplemented |
-                                                  ExportTag::kAudio |
-                                                  ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMAInitializeContext, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMASetLoopData(lpvoid_t context_ptr,
                               pointer_t<XMA_CONTEXT_DATA> loop_data) {
@@ -165,17 +162,14 @@ dword_result_t XMASetLoopData(lpvoid_t context_ptr,
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XMASetLoopData, ExportTag::kImplemented |
-                                            ExportTag::kAudio |
-                                            ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMASetLoopData, kAudio, kImplemented, kHighFrequency);
 
 dword_result_t XMAGetInputBufferReadOffset(lpvoid_t context_ptr) {
   XMA_CONTEXT_DATA context(context_ptr);
   return context.input_buffer_read_offset;
 }
-DECLARE_XBOXKRNL_EXPORT(XMAGetInputBufferReadOffset,
-                        ExportTag::kImplemented | ExportTag::kAudio |
-                            ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMAGetInputBufferReadOffset, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMASetInputBufferReadOffset(lpvoid_t context_ptr,
                                            dword_t value) {
@@ -185,9 +179,8 @@ dword_result_t XMASetInputBufferReadOffset(lpvoid_t context_ptr,
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XMASetInputBufferReadOffset,
-                        ExportTag::kImplemented | ExportTag::kAudio |
-                            ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMASetInputBufferReadOffset, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMASetInputBuffer0(lpvoid_t context_ptr, lpvoid_t buffer,
                                   dword_t packet_count) {
@@ -200,17 +193,15 @@ dword_result_t XMASetInputBuffer0(lpvoid_t context_ptr, lpvoid_t buffer,
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XMASetInputBuffer0, ExportTag::kImplemented |
-                                                ExportTag::kAudio |
-                                                ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMASetInputBuffer0, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMAIsInputBuffer0Valid(lpvoid_t context_ptr) {
   XMA_CONTEXT_DATA context(context_ptr);
   return context.input_buffer_0_valid;
 }
-DECLARE_XBOXKRNL_EXPORT(XMAIsInputBuffer0Valid, ExportTag::kImplemented |
-                                                    ExportTag::kAudio |
-                                                    ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMAIsInputBuffer0Valid, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMASetInputBuffer0Valid(lpvoid_t context_ptr) {
   XMA_CONTEXT_DATA context(context_ptr);
@@ -219,9 +210,8 @@ dword_result_t XMASetInputBuffer0Valid(lpvoid_t context_ptr) {
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XMASetInputBuffer0Valid, ExportTag::kImplemented |
-                                                     ExportTag::kAudio |
-                                                     ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMASetInputBuffer0Valid, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMASetInputBuffer1(lpvoid_t context_ptr, lpvoid_t buffer,
                                   dword_t packet_count) {
@@ -234,17 +224,15 @@ dword_result_t XMASetInputBuffer1(lpvoid_t context_ptr, lpvoid_t buffer,
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XMASetInputBuffer1, ExportTag::kImplemented |
-                                                ExportTag::kAudio |
-                                                ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMASetInputBuffer1, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMAIsInputBuffer1Valid(lpvoid_t context_ptr) {
   XMA_CONTEXT_DATA context(context_ptr);
   return context.input_buffer_1_valid;
 }
-DECLARE_XBOXKRNL_EXPORT(XMAIsInputBuffer1Valid, ExportTag::kImplemented |
-                                                    ExportTag::kAudio |
-                                                    ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMAIsInputBuffer1Valid, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMASetInputBuffer1Valid(lpvoid_t context_ptr) {
   XMA_CONTEXT_DATA context(context_ptr);
@@ -253,17 +241,15 @@ dword_result_t XMASetInputBuffer1Valid(lpvoid_t context_ptr) {
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XMASetInputBuffer1Valid, ExportTag::kImplemented |
-                                                     ExportTag::kAudio |
-                                                     ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMASetInputBuffer1Valid, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMAIsOutputBufferValid(lpvoid_t context_ptr) {
   XMA_CONTEXT_DATA context(context_ptr);
   return context.output_buffer_valid;
 }
-DECLARE_XBOXKRNL_EXPORT(XMAIsOutputBufferValid, ExportTag::kImplemented |
-                                                    ExportTag::kAudio |
-                                                    ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMAIsOutputBufferValid, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMASetOutputBufferValid(lpvoid_t context_ptr) {
   XMA_CONTEXT_DATA context(context_ptr);
@@ -272,17 +258,15 @@ dword_result_t XMASetOutputBufferValid(lpvoid_t context_ptr) {
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XMASetOutputBufferValid, ExportTag::kImplemented |
-                                                     ExportTag::kAudio |
-                                                     ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMASetOutputBufferValid, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMAGetOutputBufferReadOffset(lpvoid_t context_ptr) {
   XMA_CONTEXT_DATA context(context_ptr);
   return context.output_buffer_read_offset;
 }
-DECLARE_XBOXKRNL_EXPORT(XMAGetOutputBufferReadOffset,
-                        ExportTag::kImplemented | ExportTag::kAudio |
-                            ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMAGetOutputBufferReadOffset, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMASetOutputBufferReadOffset(lpvoid_t context_ptr,
                                             dword_t value) {
@@ -292,32 +276,28 @@ dword_result_t XMASetOutputBufferReadOffset(lpvoid_t context_ptr,
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XMASetOutputBufferReadOffset,
-                        ExportTag::kImplemented | ExportTag::kAudio |
-                            ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMASetOutputBufferReadOffset, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMAGetOutputBufferWriteOffset(lpvoid_t context_ptr) {
   XMA_CONTEXT_DATA context(context_ptr);
   return context.output_buffer_write_offset;
 }
-DECLARE_XBOXKRNL_EXPORT(XMAGetOutputBufferWriteOffset,
-                        ExportTag::kImplemented | ExportTag::kAudio |
-                            ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMAGetOutputBufferWriteOffset, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMAGetPacketMetadata(lpvoid_t context_ptr) {
   XMA_CONTEXT_DATA context(context_ptr);
   return context.packet_metadata;
 }
-DECLARE_XBOXKRNL_EXPORT(XMAGetPacketMetadata,
-                        ExportTag::kImplemented | ExportTag::kAudio);
+DECLARE_XBOXKRNL_EXPORT1(XMAGetPacketMetadata, kAudio, kImplemented);
 
 dword_result_t XMAEnableContext(lpvoid_t context_ptr) {
   StoreXmaContextIndexedRegister(kernel_state(), 0x1940, context_ptr);
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XMAEnableContext, ExportTag::kImplemented |
-                                              ExportTag::kAudio |
-                                              ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMAEnableContext, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMADisableContext(lpvoid_t context_ptr, dword_t wait) {
   X_HRESULT result = X_E_SUCCESS;
@@ -331,9 +311,8 @@ dword_result_t XMADisableContext(lpvoid_t context_ptr, dword_t wait) {
   }
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(XMADisableContext, ExportTag::kImplemented |
-                                               ExportTag::kAudio |
-                                               ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMADisableContext, kAudio, kImplemented,
+                         kHighFrequency);
 
 dword_result_t XMABlockWhileInUse(lpvoid_t context_ptr) {
   do {
@@ -345,9 +324,8 @@ dword_result_t XMABlockWhileInUse(lpvoid_t context_ptr) {
   } while (true);
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XMABlockWhileInUse, ExportTag::kImplemented |
-                                                ExportTag::kAudio |
-                                                ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(XMABlockWhileInUse, kAudio, kImplemented,
+                         kHighFrequency);
 
 void RegisterAudioXmaExports(xe::cpu::ExportResolver* export_resolver,
                              KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_crypt.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_crypt.cc
index 86f0d301b..410a9ea23 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_crypt.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_crypt.cc
@@ -58,7 +58,7 @@ void XeCryptShaInit(pointer_t<XECRYPT_SHA_STATE> sha_state) {
   sha_state->state[3] = 0x10325476;
   sha_state->state[4] = 0xC3D2E1F0;
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptShaInit, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptShaInit, kNone, kImplemented);
 
 void XeCryptShaUpdate(pointer_t<XECRYPT_SHA_STATE> sha_state, lpvoid_t input,
                       dword_t input_size) {
@@ -69,7 +69,7 @@ void XeCryptShaUpdate(pointer_t<XECRYPT_SHA_STATE> sha_state, lpvoid_t input,
 
   StoreSha1(&sha, sha_state);
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptShaUpdate, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptShaUpdate, kNone, kImplemented);
 
 void XeCryptShaFinal(pointer_t<XECRYPT_SHA_STATE> sha_state,
                      pointer_t<xe::be<uint32_t>> out, dword_t out_size) {
@@ -82,7 +82,7 @@ void XeCryptShaFinal(pointer_t<XECRYPT_SHA_STATE> sha_state,
   std::memcpy(out, digest, std::min((uint32_t)out_size, 0x14u));
   std::memcpy(sha_state->state, digest, 0x14);
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptShaFinal, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptShaFinal, kNone, kImplemented);
 
 void XeCryptSha(lpvoid_t input_1, dword_t input_1_size, lpvoid_t input_2,
                 dword_t input_2_size, lpvoid_t input_3, dword_t input_3_size,
@@ -103,7 +103,7 @@ void XeCryptSha(lpvoid_t input_1, dword_t input_1_size, lpvoid_t input_2,
   sha.finalize(digest);
   std::memcpy(output, digest, std::min((uint32_t)output_size, 0x14u));
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptSha, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptSha, kNone, kImplemented);
 
 // TODO: Size of this struct hasn't been confirmed yet.
 typedef struct {
@@ -124,7 +124,7 @@ void XeCryptSha256Init(pointer_t<XECRYPT_SHA256_STATE> sha_state) {
   sha_state->state[6] = 0x1f83d9ab;
   sha_state->state[7] = 0x5be0cd19;
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptSha256Init, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptSha256Init, kNone, kImplemented);
 
 void XeCryptSha256Update(pointer_t<XECRYPT_SHA256_STATE> sha_state,
                          lpvoid_t input, dword_t input_size) {
@@ -139,7 +139,7 @@ void XeCryptSha256Update(pointer_t<XECRYPT_SHA256_STATE> sha_state,
   std::memcpy(sha_state->buffer, sha.getBuffer(), 64);
   sha_state->count = uint32_t(sha.getTotalSize());
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptSha256Update, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptSha256Update, kNone, kImplemented);
 
 void XeCryptSha256Final(pointer_t<XECRYPT_SHA256_STATE> sha_state,
                         pointer_t<xe::be<uint32_t>> out, dword_t out_size) {
@@ -154,33 +154,33 @@ void XeCryptSha256Final(pointer_t<XECRYPT_SHA256_STATE> sha_state,
   std::memcpy(out, hash, std::min(uint32_t(out_size), 32u));
   std::memcpy(sha_state->buffer, hash, 32);
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptSha256Final, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptSha256Final, kNone, kImplemented);
 
 // Byteswap?
 dword_result_t XeCryptBnQw_SwapDwQwLeBe(lpqword_t qw_inp, lpqword_t qw_out,
                                         dword_t size) {
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptBnQw_SwapDwQwLeBe, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptBnQw_SwapDwQwLeBe, kNone, kStub);
 
 dword_result_t XeCryptBnQwNeRsaPubCrypt(lpqword_t qw_a, lpqword_t qw_b,
                                         lpvoid_t rsa) {
   // 0 indicates failure (but not a BOOL return value)
   return 1;
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptBnQwNeRsaPubCrypt, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptBnQwNeRsaPubCrypt, kNone, kStub);
 
 dword_result_t XeCryptBnDwLePkcs1Verify(lpvoid_t hash, lpvoid_t sig,
                                         dword_t size) {
   // BOOL return value
   return 1;
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptBnDwLePkcs1Verify, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptBnDwLePkcs1Verify, kNone, kStub);
 
 void XeCryptRandom(lpvoid_t buf, dword_t buf_size) {
   std::memset(buf, 0xFD, buf_size);
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptRandom, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptRandom, kNone, kStub);
 
 struct XECRYPT_DES_STATE {
   uint32_t keytab[16][2];
@@ -190,7 +190,7 @@ struct XECRYPT_DES_STATE {
 void XeCryptDesParity(lpvoid_t inp, dword_t inp_size, lpvoid_t out_ptr) {
   DES::set_parity(inp, inp_size, out_ptr);
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptDesParity, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptDesParity, kNone, kImplemented);
 
 struct XECRYPT_DES3_STATE {
   XECRYPT_DES_STATE des_state[3];
@@ -205,7 +205,7 @@ void XeCryptDes3Key(pointer_t<XECRYPT_DES3_STATE> state_ptr, lpqword_t key) {
     std::memcpy(state_ptr->des_state[i].keytab, des[i].get_sub_key(), 128);
   }
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptDes3Key, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptDes3Key, kNone, kImplemented);
 
 void XeCryptDes3Ecb(pointer_t<XECRYPT_DES3_STATE> state_ptr, lpqword_t inp,
                     lpqword_t out, dword_t encrypt) {
@@ -219,7 +219,7 @@ void XeCryptDes3Ecb(pointer_t<XECRYPT_DES3_STATE> state_ptr, lpqword_t inp,
     *out = des3.decrypt(*inp);
   }
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptDes3Ecb, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptDes3Ecb, kNone, kImplemented);
 
 void XeCryptDes3Cbc(pointer_t<XECRYPT_DES3_STATE> state_ptr, lpqword_t inp,
                     dword_t inp_size, lpqword_t out, lpqword_t feed,
@@ -245,7 +245,7 @@ void XeCryptDes3Cbc(pointer_t<XECRYPT_DES3_STATE> state_ptr, lpqword_t inp,
 
   *feed = last_block;
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptDes3Cbc, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptDes3Cbc, kNone, kImplemented);
 
 void XeCryptHmacSha(lpvoid_t key, dword_t key_size_in, lpvoid_t inp_1,
                     dword_t inp_1_size, lpvoid_t inp_2, dword_t inp_2_size,
@@ -302,7 +302,7 @@ void XeCryptHmacSha(lpvoid_t key, dword_t key_size_in, lpvoid_t inp_1,
 
   std::memcpy(out, digest, std::min((uint32_t)out_size, 0x14u));
 }
-DECLARE_XBOXKRNL_EXPORT(XeCryptHmacSha, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(XeCryptHmacSha, kNone, kImplemented);
 
 // Keys
 // TODO: Array of keys we need
@@ -330,7 +330,7 @@ dword_result_t XeKeysHmacSha(dword_t key_num, lpvoid_t inp_1,
 
   return X_STATUS_UNSUCCESSFUL;
 }
-DECLARE_XBOXKRNL_EXPORT(XeKeysHmacSha, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(XeKeysHmacSha, kNone, kImplemented);
 
 void RegisterCryptExports(xe::cpu::ExportResolver* export_resolver,
                           KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_debug.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_debug.cc
index 45510bac2..994c55f57 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_debug.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_debug.cc
@@ -20,7 +20,7 @@ namespace kernel {
 namespace xboxkrnl {
 
 void DbgBreakPoint() { xe::debugging::Break(); }
-DECLARE_XBOXKRNL_EXPORT(DbgBreakPoint, ExportTag::kImportant);
+DECLARE_XBOXKRNL_EXPORT2(DbgBreakPoint, kDebug, kStub, kImportant);
 
 // https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
 typedef struct {
@@ -31,50 +31,108 @@ typedef struct {
 } X_THREADNAME_INFO;
 static_assert_size(X_THREADNAME_INFO, 0x10);
 
-void RtlRaiseException(pointer_t<X_EXCEPTION_RECORD> record) {
-  if (record->exception_code == 0x406D1388) {
-    // SetThreadName. FFS.
-    // https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
+void HandleSetThreadName(pointer_t<X_EXCEPTION_RECORD> record) {
+  // SetThreadName. FFS.
+  // https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
 
-    // TODO(benvanik): check record->number_parameters to make sure it's a
-    // correct size.
-    auto thread_info =
-        reinterpret_cast<X_THREADNAME_INFO*>(&record->exception_information[0]);
+  // TODO(benvanik): check record->number_parameters to make sure it's a
+  // correct size.
+  auto thread_info =
+      reinterpret_cast<X_THREADNAME_INFO*>(&record->exception_information[0]);
 
-    assert_true(thread_info->type == 0x1000);
-    auto name =
-        kernel_memory()->TranslateVirtual<const char*>(thread_info->name_ptr);
+  assert_true(thread_info->type == 0x1000);
 
-    object_ref<XThread> thread;
-    if (thread_info->thread_id == -1) {
-      // Current thread.
-      thread = retain_object(XThread::GetCurrentThread());
-    } else {
-      // Lookup thread by ID.
-      thread = kernel_state()->GetThreadByID(thread_info->thread_id);
-    }
-
-    if (thread) {
-      XELOGD("SetThreadName(%d, %s)", thread->thread_id(), name);
-      thread->set_name(name);
-    }
-
-    // TODO(benvanik): unwinding required here?
+  if (!thread_info->name_ptr) {
+    XELOGD("SetThreadName called with null name_ptr");
     return;
   }
 
-  if (record->exception_code == 0xE06D7363) {
-    // C++ exception.
-    // http://blogs.msdn.com/b/oldnewthing/archive/2010/07/30/10044061.aspx
-    xe::debugging::Break();
-    return;
+  auto name =
+      kernel_memory()->TranslateVirtual<const char*>(thread_info->name_ptr);
+
+  object_ref<XThread> thread;
+  if (thread_info->thread_id == -1) {
+    // Current thread.
+    thread = retain_object(XThread::GetCurrentThread());
+  } else {
+    // Lookup thread by ID.
+    thread = kernel_state()->GetThreadByID(thread_info->thread_id);
+  }
+
+  if (thread) {
+    XELOGD("SetThreadName(%d, %s)", thread->thread_id(), name);
+    thread->set_name(name);
+  }
+
+  // TODO(benvanik): unwinding required here?
+}
+
+typedef struct {
+  xe::be<int32_t> mdisp;
+  xe::be<int32_t> pdisp;
+  xe::be<int32_t> vdisp;
+} x_PMD;
+
+typedef struct {
+  xe::be<uint32_t> properties;
+  xe::be<uint32_t> type_ptr;
+  x_PMD this_displacement;
+  xe::be<int32_t> size_or_offset;
+  xe::be<uint32_t> copy_function_ptr;
+} x_s__CatchableType;
+
+typedef struct {
+  xe::be<int32_t> number_catchable_types;
+  xe::be<uint32_t> catchable_type_ptrs[1];
+} x_s__CatchableTypeArray;
+
+typedef struct {
+  xe::be<uint32_t> attributes;
+  xe::be<uint32_t> unwind_ptr;
+  xe::be<uint32_t> forward_compat_ptr;
+  xe::be<uint32_t> catchable_type_array_ptr;
+} x_s__ThrowInfo;
+
+void HandleCppException(pointer_t<X_EXCEPTION_RECORD> record) {
+  // C++ exception.
+  // https://blogs.msdn.com/b/oldnewthing/archive/2010/07/30/10044061.aspx
+  // http://www.drdobbs.com/visual-c-exception-handling-instrumentat/184416600
+  // http://www.openrce.org/articles/full_view/21
+
+  assert_true(record->number_parameters == 3);
+  assert_true(record->exception_information[0] == 0x19930520);
+
+  auto thrown_ptr = record->exception_information[1];
+  auto thrown = kernel_memory()->TranslateVirtual(thrown_ptr);
+  auto vftable_ptr = *reinterpret_cast<xe::be<uint32_t>*>(thrown);
+
+  auto throw_info_ptr = record->exception_information[2];
+  auto throw_info =
+      kernel_memory()->TranslateVirtual<x_s__ThrowInfo*>(throw_info_ptr);
+  auto catchable_types =
+      kernel_memory()->TranslateVirtual<x_s__CatchableTypeArray*>(
+          throw_info->catchable_type_array_ptr);
+
+  xe::debugging::Break();
+}
+
+void RtlRaiseException(pointer_t<X_EXCEPTION_RECORD> record) {
+  switch (record->exception_code) {
+    case 0x406D1388: {
+      HandleSetThreadName(record);
+      return;
+    }
+    case 0xE06D7363: {
+      HandleCppException(record);
+      return;
+    }
   }
 
   // TODO(benvanik): unwinding.
   // This is going to suck.
   xe::debugging::Break();
 }
-DECLARE_XBOXKRNL_EXPORT(RtlRaiseException, ExportTag::kImportant);
+DECLARE_XBOXKRNL_EXPORT2(RtlRaiseException, kDebug, kStub, kImportant);
 
 void KeBugCheckEx(dword_t code, dword_t param1, dword_t param2, dword_t param3,
                   dword_t param4) {
@@ -84,10 +142,10 @@ void KeBugCheckEx(dword_t code, dword_t param1, dword_t param2, dword_t param3,
   xe::debugging::Break();
   assert_always();
 }
-DECLARE_XBOXKRNL_EXPORT(KeBugCheckEx, ExportTag::kImportant);
+DECLARE_XBOXKRNL_EXPORT2(KeBugCheckEx, kDebug, kStub, kImportant);
 
 void KeBugCheck(dword_t code) { KeBugCheckEx(code, 0, 0, 0, 0); }
-DECLARE_XBOXKRNL_EXPORT(KeBugCheck, ExportTag::kImportant);
+DECLARE_XBOXKRNL_EXPORT2(KeBugCheck, kDebug, kImplemented, kImportant);
 
 void RegisterDebugExports(xe::cpu::ExportResolver* export_resolver,
                           KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_error.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_error.cc
index 6718b130b..114111624 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_error.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_error.cc
@@ -971,7 +971,7 @@ const error_lookup_table error_tables[] = {
 };
 #undef MAKE_ENTRY
 
-dword_result_t RtlNtStatusToDosError(dword_t source_status) {
+uint32_t xeRtlNtStatusToDosError(uint32_t source_status) {
   uint32_t status = source_status;
   if (!status || (status & 0x20000000)) {
     return status;
@@ -997,7 +997,7 @@ dword_result_t RtlNtStatusToDosError(dword_t source_status) {
       if (!result) {
         break;
       }
-      XELOGI("RtlNtStatusToDosError => %X", result);
+      XELOGI("RtlNtStatusToDosError %X => %X", status, result);
       return result;
     }
     ++error_table;
@@ -1010,8 +1010,12 @@ dword_result_t RtlNtStatusToDosError(dword_t source_status) {
   XELOGE("RtlNtStatusToDosError lookup NOT IMPLEMENTED");
   return 317;  // ERROR_MR_MID_NOT_FOUND
 }
-DECLARE_XBOXKRNL_EXPORT(RtlNtStatusToDosError,
-                        ExportTag::kImportant | ExportTag::kLogResult);
+
+dword_result_t RtlNtStatusToDosError(dword_t source_status) {
+  return xeRtlNtStatusToDosError(source_status);
+}
+DECLARE_XBOXKRNL_EXPORT3(RtlNtStatusToDosError, kNone, kImportant,
+                         kHighFrequency, kLogResult);
 
 void RegisterErrorExports(xe::cpu::ExportResolver* export_resolver,
                           KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_error.h b/src/xenia/kernel/xboxkrnl/xboxkrnl_error.h
index 0d0a8be19..9cd5240fc 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_error.h
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_error.h
@@ -17,7 +17,7 @@ namespace xe {
 namespace kernel {
 namespace xboxkrnl {
 
-dword_result_t RtlNtStatusToDosError(dword_t source_status);
+uint32_t xeRtlNtStatusToDosError(uint32_t source_status);
 
 }  // namespace xboxkrnl
 }  // namespace kernel
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_hal.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_hal.cc
index 658275483..658cc0d24 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_hal.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_hal.cc
@@ -29,7 +29,7 @@ void HalReturnToFirmware(dword_t routine) {
   XELOGE("Game requested shutdown via HalReturnToFirmware");
   exit(0);
 }
-DECLARE_XBOXKRNL_EXPORT(HalReturnToFirmware, ExportTag::kImportant);
+DECLARE_XBOXKRNL_EXPORT2(HalReturnToFirmware, kNone, kStub, kImportant);
 
 void RegisterHalExports(xe::cpu::ExportResolver* export_resolver,
                         KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_hid.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_hid.cc
index bf63b923b..0ce308237 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_hid.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_hid.cc
@@ -25,12 +25,12 @@ dword_result_t HidReadKeys(dword_t unk1, unknown_t unk2, unknown_t unk3) {
    * Other errors appear to be ignored?
    *
    * unk1 is 0
-   * unk2 is a pointer to &unk3[2], possibly a 6-byte vuffer
+   * unk2 is a pointer to &unk3[2], possibly a 6-byte buffer
    * unk3 is a pointer to a 20-byte buffer
    */
   return 0xC000009D;
 }
-DECLARE_XBOXKRNL_EXPORT(HidReadKeys, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(HidReadKeys, kInput, kStub);
 
 void RegisterHidExports(xe::cpu::ExportResolver* export_resolver,
                         KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_io.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_io.cc
index c3bbb5e7e..63ad15009 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_io.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_io.cc
@@ -24,7 +24,7 @@ namespace xe {
 namespace kernel {
 namespace xboxkrnl {
 
-// http://msdn.microsoft.com/en-us/library/windows/hardware/ff540287.aspx
+// https://msdn.microsoft.com/en-us/library/windows/hardware/ff540287.aspx
 struct X_FILE_FS_VOLUME_INFORMATION {
   // FILE_FS_VOLUME_INFORMATION
   xe::be<uint64_t> creation_time;
@@ -45,7 +45,7 @@ struct X_FILE_FS_SIZE_INFORMATION {
 };
 static_assert_size(X_FILE_FS_SIZE_INFORMATION, 24);
 
-// http://msdn.microsoft.com/en-us/library/windows/hardware/ff540251(v=vs.85).aspx
+// https://msdn.microsoft.com/en-us/library/windows/hardware/ff540251(v=vs.85).aspx
 struct X_FILE_FS_ATTRIBUTE_INFORMATION {
   // FILE_FS_ATTRIBUTE_INFORMATION
   xe::be<uint32_t> attributes;
@@ -56,7 +56,7 @@ struct X_FILE_FS_ATTRIBUTE_INFORMATION {
 static_assert_size(X_FILE_FS_ATTRIBUTE_INFORMATION, 16);
 
 struct CreateOptions {
-  // http://processhacker.sourceforge.net/doc/ntioapi_8h.html
+  // https://processhacker.sourceforge.io/doc/ntioapi_8h.html
   static const uint32_t FILE_DIRECTORY_FILE = 0x00000001;
   // Optimization - files access will be sequential, not random.
   static const uint32_t FILE_SEQUENTIAL_ONLY = 0x00000004;
@@ -133,7 +133,7 @@ dword_result_t NtCreateFile(lpdword_t handle_out, dword_t desired_access,
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(NtCreateFile, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(NtCreateFile, kFileSystem, kImplemented);
 
 dword_result_t NtOpenFile(lpdword_t handle_out, dword_t desired_access,
                           pointer_t<X_OBJECT_ATTRIBUTES> object_attributes,
@@ -144,7 +144,7 @@ dword_result_t NtOpenFile(lpdword_t handle_out, dword_t desired_access,
                       static_cast<uint32_t>(xe::vfs::FileDisposition::kOpen),
                       open_options);
 }
-DECLARE_XBOXKRNL_EXPORT(NtOpenFile, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(NtOpenFile, kFileSystem, kImplemented);
 
 dword_result_t NtReadFile(dword_t file_handle, dword_t event_handle,
                           lpvoid_t apc_routine_ptr, lpvoid_t apc_context,
@@ -235,8 +235,7 @@ dword_result_t NtReadFile(dword_t file_handle, dword_t event_handle,
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(NtReadFile,
-                        ExportTag::kImplemented | ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(NtReadFile, kFileSystem, kImplemented, kHighFrequency);
 
 dword_result_t NtWriteFile(dword_t file_handle, dword_t event_handle,
                            function_t apc_routine, lpvoid_t apc_context,
@@ -311,7 +310,7 @@ dword_result_t NtWriteFile(dword_t file_handle, dword_t event_handle,
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(NtWriteFile, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(NtWriteFile, kFileSystem, kImplemented);
 
 dword_result_t NtCreateIoCompletion(lpdword_t out_handle,
                                     dword_t desired_access,
@@ -324,7 +323,7 @@ dword_result_t NtCreateIoCompletion(lpdword_t out_handle,
 
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(NtCreateIoCompletion, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(NtCreateIoCompletion, kFileSystem, kImplemented);
 
 // Dequeues a packet from the completion port.
 dword_result_t NtRemoveIoCompletion(
@@ -359,7 +358,7 @@ dword_result_t NtRemoveIoCompletion(
 
   return status;
 }
-DECLARE_XBOXKRNL_EXPORT(NtRemoveIoCompletion, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(NtRemoveIoCompletion, kFileSystem, kImplemented);
 
 dword_result_t NtSetInformationFile(
     dword_t file_handle, pointer_t<X_IO_STATUS_BLOCK> io_status_block,
@@ -434,8 +433,8 @@ dword_result_t NtSetInformationFile(
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(NtSetInformationFile,
-                        ExportTag::kImplemented | ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(NtSetInformationFile, kFileSystem, kImplemented,
+                         kHighFrequency);
 
 struct X_IO_STATUS_BLOCK {
   union {
@@ -550,8 +549,7 @@ dword_result_t NtQueryInformationFile(
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(NtQueryInformationFile,
-                        ExportTag::kImplemented | ExportTag::kFileSystem);
+DECLARE_XBOXKRNL_EXPORT1(NtQueryInformationFile, kFileSystem, kImplemented);
 
 dword_result_t NtQueryFullAttributesFile(
     pointer_t<X_OBJECT_ATTRIBUTES> obj_attribs,
@@ -587,7 +585,7 @@ dword_result_t NtQueryFullAttributesFile(
 
   return X_STATUS_NO_SUCH_FILE;
 }
-DECLARE_XBOXKRNL_EXPORT(NtQueryFullAttributesFile, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(NtQueryFullAttributesFile, kFileSystem, kImplemented);
 
 dword_result_t NtQueryVolumeInformationFile(
     dword_t file_handle, pointer_t<X_IO_STATUS_BLOCK> io_status_block_ptr,
@@ -662,7 +660,8 @@ dword_result_t NtQueryVolumeInformationFile(
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(NtQueryVolumeInformationFile, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(NtQueryVolumeInformationFile, kFileSystem,
+                         kImplemented);
 
 dword_result_t NtQueryDirectoryFile(
     dword_t file_handle, dword_t event_handle, function_t apc_routine,
@@ -702,7 +701,7 @@ dword_result_t NtQueryDirectoryFile(
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(NtQueryDirectoryFile, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(NtQueryDirectoryFile, kFileSystem, kImplemented);
 
 dword_result_t NtFlushBuffersFile(
     dword_t file_handle, pointer_t<X_IO_STATUS_BLOCK> io_status_block_ptr) {
@@ -715,17 +714,17 @@ dword_result_t NtFlushBuffersFile(
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(NtFlushBuffersFile, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(NtFlushBuffersFile, kFileSystem, kStub);
 
 dword_result_t FscGetCacheElementCount(dword_t r3) { return 0; }
-DECLARE_XBOXKRNL_EXPORT(FscGetCacheElementCount, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(FscGetCacheElementCount, kFileSystem, kStub);
 
 dword_result_t FscSetCacheElementCount(dword_t unk_0, dword_t unk_1) {
   // unk_0 = 0
   // unk_1 looks like a count? in what units? 256 is a common value
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(FscSetCacheElementCount, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(FscSetCacheElementCount, kFileSystem, kStub);
 
 void RegisterIoExports(xe::cpu::ExportResolver* export_resolver,
                        KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_memory.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_memory.cc
index 0ef461683..177398fc0 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_memory.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_memory.cc
@@ -161,8 +161,7 @@ dword_result_t NtAllocateVirtualMemory(lpdword_t base_addr_ptr,
   *region_size_ptr = adjusted_size;
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(NtAllocateVirtualMemory,
-                        ExportTag::kImplemented | ExportTag::kMemory);
+DECLARE_XBOXKRNL_EXPORT1(NtAllocateVirtualMemory, kMemory, kImplemented);
 
 dword_result_t NtProtectVirtualMemory(lpdword_t base_addr_ptr,
                                       lpdword_t region_size_ptr,
@@ -210,8 +209,7 @@ dword_result_t NtProtectVirtualMemory(lpdword_t base_addr_ptr,
 
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(NtProtectVirtualMemory,
-                        ExportTag::kImplemented | ExportTag::kMemory);
+DECLARE_XBOXKRNL_EXPORT1(NtProtectVirtualMemory, kMemory, kImplemented);
 
 dword_result_t NtFreeVirtualMemory(lpdword_t base_addr_ptr,
                                    lpdword_t region_size_ptr, dword_t free_type,
@@ -252,7 +250,7 @@ dword_result_t NtFreeVirtualMemory(lpdword_t base_addr_ptr,
   *region_size_ptr = region_size_value;
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(NtFreeVirtualMemory, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(NtFreeVirtualMemory, kMemory, kImplemented);
 
 struct X_MEMORY_BASIC_INFORMATION {
   be<uint32_t> base_address;
@@ -291,7 +289,7 @@ dword_result_t NtQueryVirtualMemory(
 
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(NtQueryVirtualMemory, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(NtQueryVirtualMemory, kMemory, kImplemented);
 
 dword_result_t MmAllocatePhysicalMemoryEx(dword_t flags, dword_t region_size,
                                           dword_t protect_bits,
@@ -344,8 +342,14 @@ dword_result_t MmAllocatePhysicalMemoryEx(dword_t flags, dword_t region_size,
 
   return base_address;
 }
-DECLARE_XBOXKRNL_EXPORT(MmAllocatePhysicalMemoryEx,
-                        ExportTag::kImplemented | ExportTag::kMemory);
+DECLARE_XBOXKRNL_EXPORT1(MmAllocatePhysicalMemoryEx, kMemory, kImplemented);
+
+dword_result_t MmAllocatePhysicalMemory(dword_t flags, dword_t region_size,
+                                        dword_t protect_bits) {
+  return MmAllocatePhysicalMemoryEx(flags, region_size, protect_bits, 0,
+                                    0xFFFFFFFFu, 0);
+}
+DECLARE_XBOXKRNL_EXPORT1(MmAllocatePhysicalMemory, kMemory, kImplemented);
 
 void MmFreePhysicalMemory(dword_t type, dword_t base_address) {
   // base_address = result of MmAllocatePhysicalMemory.
@@ -355,7 +359,7 @@ void MmFreePhysicalMemory(dword_t type, dword_t base_address) {
   auto heap = kernel_state()->memory()->LookupHeap(base_address);
   heap->Release(base_address);
 }
-DECLARE_XBOXKRNL_EXPORT(MmFreePhysicalMemory, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(MmFreePhysicalMemory, kMemory, kImplemented);
 
 dword_result_t MmQueryAddressProtect(dword_t base_address) {
   auto heap = kernel_state()->memory()->LookupHeap(base_address);
@@ -367,7 +371,8 @@ dword_result_t MmQueryAddressProtect(dword_t base_address) {
 
   return access;
 }
-DECLARE_XBOXKRNL_EXPORT(MmQueryAddressProtect, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT2(MmQueryAddressProtect, kMemory, kImplemented,
+                         kHighFrequency);
 
 void MmSetAddressProtect(lpvoid_t base_address, dword_t region_size,
                          dword_t protect_bits) {
@@ -375,8 +380,7 @@ void MmSetAddressProtect(lpvoid_t base_address, dword_t region_size,
   auto heap = kernel_memory()->LookupHeap(base_address);
   heap->Protect(base_address.guest_address(), region_size, protect);
 }
-DECLARE_XBOXKRNL_EXPORT(MmSetAddressProtect,
-                        ExportTag::kImplemented | ExportTag::kMemory);
+DECLARE_XBOXKRNL_EXPORT1(MmSetAddressProtect, kMemory, kImplemented);
 
 dword_result_t MmQueryAllocationSize(lpvoid_t base_address) {
   auto heap = kernel_state()->memory()->LookupHeap(base_address);
@@ -387,7 +391,7 @@ dword_result_t MmQueryAllocationSize(lpvoid_t base_address) {
 
   return size;
 }
-DECLARE_XBOXKRNL_EXPORT(MmQueryAllocationSize, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(MmQueryAllocationSize, kMemory, kImplemented);
 
 // https://code.google.com/p/vdash/source/browse/trunk/vdash/include/kernel.h
 struct X_MM_QUERY_STATISTICS_SECTION {
@@ -490,9 +494,9 @@ dword_result_t MmQueryStatistics(
 
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(MmQueryStatistics, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(MmQueryStatistics, kMemory, kImplemented);
 
-// http://msdn.microsoft.com/en-us/library/windows/hardware/ff554547(v=vs.85).aspx
+// https://msdn.microsoft.com/en-us/library/windows/hardware/ff554547(v=vs.85).aspx
 dword_result_t MmGetPhysicalAddress(dword_t base_address) {
   // PHYSICAL_ADDRESS MmGetPhysicalAddress(
   //   _In_  PVOID BaseAddress
@@ -507,7 +511,7 @@ dword_result_t MmGetPhysicalAddress(dword_t base_address) {
 
   return physical_address;
 }
-DECLARE_XBOXKRNL_EXPORT(MmGetPhysicalAddress, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(MmGetPhysicalAddress, kMemory, kImplemented);
 
 dword_result_t MmMapIoSpace(dword_t unk0, lpvoid_t src_address, dword_t size,
                             dword_t flags) {
@@ -520,7 +524,7 @@ dword_result_t MmMapIoSpace(dword_t unk0, lpvoid_t src_address, dword_t size,
 
   return src_address.guest_address();
 }
-DECLARE_XBOXKRNL_EXPORT(MmMapIoSpace, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(MmMapIoSpace, kMemory, kImplemented);
 
 dword_result_t ExAllocatePoolTypeWithTag(dword_t size, dword_t tag,
                                          dword_t zero) {
@@ -537,27 +541,27 @@ dword_result_t ExAllocatePoolTypeWithTag(dword_t size, dword_t tag,
 
   return addr;
 }
-DECLARE_XBOXKRNL_EXPORT(ExAllocatePoolTypeWithTag, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(ExAllocatePoolTypeWithTag, kMemory, kImplemented);
 
 void ExFreePool(lpvoid_t base_address) {
   kernel_state()->memory()->SystemHeapFree(base_address);
 }
-DECLARE_XBOXKRNL_EXPORT(ExFreePool, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(ExFreePool, kMemory, kImplemented);
 
 dword_result_t KeGetImagePageTableEntry(lpvoid_t address) {
   // Unknown
   return 1;
 }
-DECLARE_XBOXKRNL_EXPORT(KeGetImagePageTableEntry, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(KeGetImagePageTableEntry, kMemory, kStub);
 
 dword_result_t KeLockL2() {
   // TODO
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(KeLockL2, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(KeLockL2, kMemory, kStub);
 
 void KeUnlockL2() {}
-DECLARE_XBOXKRNL_EXPORT(KeUnlockL2, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(KeUnlockL2, kMemory, kStub);
 
 dword_result_t MmCreateKernelStack(dword_t stack_size, dword_t r4) {
   assert_zero(r4);  // Unknown argument.
@@ -574,7 +578,7 @@ dword_result_t MmCreateKernelStack(dword_t stack_size, dword_t r4) {
                    &stack_address);
   return stack_address + stack_size;
 }
-DECLARE_XBOXKRNL_EXPORT(MmCreateKernelStack, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(MmCreateKernelStack, kMemory, kImplemented);
 
 dword_result_t MmDeleteKernelStack(lpvoid_t stack_base, lpvoid_t stack_end) {
   // Release the stack (where stack_end is the low address)
@@ -584,7 +588,7 @@ dword_result_t MmDeleteKernelStack(lpvoid_t stack_base, lpvoid_t stack_end) {
 
   return X_STATUS_UNSUCCESSFUL;
 }
-DECLARE_XBOXKRNL_EXPORT(MmDeleteKernelStack, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(MmDeleteKernelStack, kMemory, kImplemented);
 
 void RegisterMemoryExports(xe::cpu::ExportResolver* export_resolver,
                            KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_misc.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_misc.cc
index 2524c396f..834b5102f 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_misc.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_misc.cc
@@ -21,7 +21,7 @@ namespace xboxkrnl {
 void KeEnableFpuExceptions(dword_t enabled) {
   // TODO(benvanik): can we do anything about exceptions?
 }
-DECLARE_XBOXKRNL_EXPORT(KeEnableFpuExceptions, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(KeEnableFpuExceptions, kNone, kStub);
 
 void RegisterMiscExports(xe::cpu::ExportResolver* export_resolver,
                          KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_module.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_module.cc
index 706c58ca8..f38d27d35 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_module.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_module.cc
@@ -159,6 +159,14 @@ XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state)
   xe::store_and_swap<uint8_t>(lpXboxHardwareInfo + 4, 0x06);  // cpu count
   // Remaining 11b are zeroes?
 
+  // ExConsoleGameRegion, probably same values as keyvault region uses?
+  // Just return all 0xFF, should satisfy anything that checks it
+  uint32_t pExConsoleGameRegion = memory_->SystemHeapAlloc(4);
+  auto lpExConsoleGameRegion = memory_->TranslateVirtual(pExConsoleGameRegion);
+  export_resolver_->SetVariableMapping(
+      "xboxkrnl.exe", ordinals::ExConsoleGameRegion, pExConsoleGameRegion);
+  xe::store<uint32_t>(lpExConsoleGameRegion, 0xFFFFFFFF);
+
   // XexExecutableModuleHandle (?**)
   // Games try to dereference this to get a pointer to some module struct.
   // So far it seems like it's just in loader code, and only used to look up
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_modules.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_modules.cc
index 1a6031422..b10a890da 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_modules.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_modules.cc
@@ -26,8 +26,8 @@ X_STATUS xeExGetXConfigSetting(uint16_t category, uint16_t setting,
   uint32_t value = 0;
 
   // TODO(benvanik): have real structs here that just get copied from.
-  // http://free60.org/XConfig
-  // http://freestyledash.googlecode.com/svn/trunk/Freestyle/Tools/Generic/ExConfig.h
+  // https://free60project.github.io/wiki/XConfig.html
+  // https://github.com/oukiar/freestyledash/blob/master/Freestyle/Tools/Generic/ExConfig.h
   switch (category) {
     case 0x0002:
       // XCONFIG_SECURED_CATEGORY
@@ -113,8 +113,7 @@ dword_result_t ExGetXConfigSetting(word_t category, word_t setting,
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(ExGetXConfigSetting,
-                        ExportTag::kImplemented | ExportTag::kModules);
+DECLARE_XBOXKRNL_EXPORT1(ExGetXConfigSetting, kModules, kImplemented);
 
 dword_result_t XexCheckExecutablePrivilege(dword_t privilege) {
   // BOOL
@@ -134,8 +133,7 @@ dword_result_t XexCheckExecutablePrivilege(dword_t privilege) {
 
   return (flags & mask) > 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XexCheckExecutablePrivilege,
-                        ExportTag::kImplemented | ExportTag::kModules);
+DECLARE_XBOXKRNL_EXPORT1(XexCheckExecutablePrivilege, kModules, kImplemented);
 
 dword_result_t XexGetModuleHandle(lpstring_t module_name,
                                   lpdword_t hmodule_ptr) {
@@ -157,8 +155,7 @@ dword_result_t XexGetModuleHandle(lpstring_t module_name,
 
   return X_ERROR_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(XexGetModuleHandle,
-                        ExportTag::kImplemented | ExportTag::kModules);
+DECLARE_XBOXKRNL_EXPORT1(XexGetModuleHandle, kModules, kImplemented);
 
 dword_result_t XexGetModuleSection(lpvoid_t hmodule, lpstring_t name,
                                    lpdword_t data_ptr, lpdword_t size_ptr) {
@@ -179,8 +176,7 @@ dword_result_t XexGetModuleSection(lpvoid_t hmodule, lpstring_t name,
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(XexGetModuleSection,
-                        ExportTag::kImplemented | ExportTag::kModules);
+DECLARE_XBOXKRNL_EXPORT1(XexGetModuleSection, kModules, kImplemented);
 
 dword_result_t XexLoadImage(lpstring_t module_name, dword_t module_flags,
                             dword_t min_version, lpdword_t hmodule_ptr) {
@@ -213,8 +209,7 @@ dword_result_t XexLoadImage(lpstring_t module_name, dword_t module_flags,
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(XexLoadImage,
-                        ExportTag::kImplemented | ExportTag::kModules);
+DECLARE_XBOXKRNL_EXPORT1(XexLoadImage, kModules, kImplemented);
 
 dword_result_t XexUnloadImage(lpvoid_t hmodule) {
   auto module = XModule::GetFromHModule(kernel_state(), hmodule);
@@ -234,8 +229,7 @@ dword_result_t XexUnloadImage(lpvoid_t hmodule) {
 
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(XexUnloadImage,
-                        ExportTag::kImplemented | ExportTag::kModules);
+DECLARE_XBOXKRNL_EXPORT1(XexUnloadImage, kModules, kImplemented);
 
 dword_result_t XexGetProcedureAddress(lpvoid_t hmodule, dword_t ordinal,
                                       lpdword_t out_function_ptr) {
@@ -273,7 +267,7 @@ dword_result_t XexGetProcedureAddress(lpvoid_t hmodule, dword_t ordinal,
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(XexGetProcedureAddress, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(XexGetProcedureAddress, kModules, kImplemented);
 
 void ExRegisterTitleTerminateNotification(
     pointer_t<X_EX_TITLE_TERMINATE_REGISTRATION> reg, dword_t create) {
@@ -286,8 +280,8 @@ void ExRegisterTitleTerminateNotification(
     kernel_state()->RemoveTitleTerminateNotification(reg->notification_routine);
   }
 }
-DECLARE_XBOXKRNL_EXPORT(ExRegisterTitleTerminateNotification,
-                        ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(ExRegisterTitleTerminateNotification, kModules,
+                         kImplemented);
 
 void RegisterModuleExports(xe::cpu::ExportResolver* export_resolver,
                            KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_ob.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_ob.cc
index 55a55c559..7ac5d5377 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_ob.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_ob.cc
@@ -44,7 +44,7 @@ dword_result_t ObOpenObjectByName(lpunknown_t obj_attributes_ptr,
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(ObOpenObjectByName, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(ObOpenObjectByName, kNone, kImplemented);
 
 dword_result_t ObOpenObjectByPointer(lpvoid_t object_ptr,
                                      lpdword_t out_handle_ptr) {
@@ -58,7 +58,7 @@ dword_result_t ObOpenObjectByPointer(lpvoid_t object_ptr,
   *out_handle_ptr = object->handle();
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(ObOpenObjectByPointer, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(ObOpenObjectByPointer, kNone, kImplemented);
 
 dword_result_t ObLookupThreadByThreadId(dword_t thread_id,
                                         lpdword_t out_object_ptr) {
@@ -72,7 +72,7 @@ dword_result_t ObLookupThreadByThreadId(dword_t thread_id,
   *out_object_ptr = thread->guest_object();
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(ObLookupThreadByThreadId, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(ObLookupThreadByThreadId, kNone, kImplemented);
 
 dword_result_t ObReferenceObjectByHandle(dword_t handle,
                                          dword_t object_type_ptr,
@@ -109,6 +109,11 @@ dword_result_t ObReferenceObjectByHandle(dword_t handle,
           } break;
         }
       } break;
+      case 0xD00EBEEF: {  // ExEventObjectType
+        assert(object->type() == XObject::kTypeEvent);
+        native_ptr = object->guest_object();
+        assert_not_zero(native_ptr);
+      } break;
       case 0xD017BEEF: {  // ExSemaphoreObjectType
         assert(object->type() == XObject::kTypeSemaphore);
         native_ptr = object->guest_object();
@@ -137,7 +142,7 @@ dword_result_t ObReferenceObjectByHandle(dword_t handle,
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(ObReferenceObjectByHandle, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(ObReferenceObjectByHandle, kNone, kImplemented);
 
 dword_result_t ObDereferenceObject(dword_t native_ptr) {
   // Check if a dummy value from ObReferenceObjectByHandle.
@@ -153,7 +158,7 @@ dword_result_t ObDereferenceObject(dword_t native_ptr) {
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(ObDereferenceObject, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(ObDereferenceObject, kNone, kImplemented);
 
 dword_result_t ObCreateSymbolicLink(pointer_t<X_ANSI_STRING> path,
                                     pointer_t<X_ANSI_STRING> target) {
@@ -174,7 +179,7 @@ dword_result_t ObCreateSymbolicLink(pointer_t<X_ANSI_STRING> path,
 
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(ObCreateSymbolicLink, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(ObCreateSymbolicLink, kNone, kImplemented);
 
 dword_result_t ObDeleteSymbolicLink(pointer_t<X_ANSI_STRING> path) {
   auto path_str = path->to_string(kernel_memory()->virtual_membase());
@@ -184,7 +189,7 @@ dword_result_t ObDeleteSymbolicLink(pointer_t<X_ANSI_STRING> path) {
 
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(ObDeleteSymbolicLink, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(ObDeleteSymbolicLink, kNone, kImplemented);
 
 dword_result_t NtDuplicateObject(dword_t handle, lpdword_t new_handle_ptr,
                                  dword_t options) {
@@ -209,12 +214,12 @@ dword_result_t NtDuplicateObject(dword_t handle, lpdword_t new_handle_ptr,
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(NtDuplicateObject, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(NtDuplicateObject, kNone, kImplemented);
 
 dword_result_t NtClose(dword_t handle) {
   return kernel_state()->object_table()->ReleaseHandle(handle);
 }
-DECLARE_XBOXKRNL_EXPORT(NtClose, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(NtClose, kNone, kImplemented);
 
 void RegisterObExports(xe::cpu::ExportResolver* export_resolver,
                        KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_rtl.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_rtl.cc
index 7ac9cd05c..2b3ab5f67 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_rtl.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_rtl.cc
@@ -33,7 +33,7 @@ namespace xe {
 namespace kernel {
 namespace xboxkrnl {
 
-// http://msdn.microsoft.com/en-us/library/ff561778
+// https://msdn.microsoft.com/en-us/library/ff561778
 dword_result_t RtlCompareMemory(lpvoid_t source1, lpvoid_t source2,
                                 dword_t length) {
   uint8_t* p1 = source1;
@@ -52,9 +52,9 @@ dword_result_t RtlCompareMemory(lpvoid_t source1, lpvoid_t source2,
 
   return c;
 }
-DECLARE_XBOXKRNL_EXPORT(RtlCompareMemory, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlCompareMemory, kMemory, kImplemented);
 
-// http://msdn.microsoft.com/en-us/library/ff552123
+// https://msdn.microsoft.com/en-us/library/ff552123
 dword_result_t RtlCompareMemoryUlong(lpvoid_t source, dword_t length,
                                      dword_t pattern) {
   // Return 0 if source/length not aligned
@@ -73,9 +73,9 @@ dword_result_t RtlCompareMemoryUlong(lpvoid_t source, dword_t length,
 
   return n;
 }
-DECLARE_XBOXKRNL_EXPORT(RtlCompareMemoryUlong, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlCompareMemoryUlong, kMemory, kImplemented);
 
-// http://msdn.microsoft.com/en-us/library/ff552263
+// https://msdn.microsoft.com/en-us/library/ff552263
 void RtlFillMemoryUlong(lpvoid_t destination, dword_t length, dword_t pattern) {
   // NOTE: length must be % 4, so we can work on uint32s.
   uint32_t count = length >> 2;
@@ -86,7 +86,7 @@ void RtlFillMemoryUlong(lpvoid_t destination, dword_t length, dword_t pattern) {
     *p = swapped_pattern;
   }
 }
-DECLARE_XBOXKRNL_EXPORT(RtlFillMemoryUlong, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlFillMemoryUlong, kMemory, kImplemented);
 
 dword_result_t RtlUpperChar(dword_t in) {
   char c = in & 0xFF;
@@ -96,7 +96,7 @@ dword_result_t RtlUpperChar(dword_t in) {
 
   return c;
 }
-DECLARE_XBOXKRNL_EXPORT(RtlUpperChar, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlUpperChar, kNone, kImplemented);
 
 dword_result_t RtlLowerChar(dword_t in) {
   char c = in & 0xFF;
@@ -106,7 +106,7 @@ dword_result_t RtlLowerChar(dword_t in) {
 
   return c;
 }
-DECLARE_XBOXKRNL_EXPORT(RtlLowerChar, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlLowerChar, kNone, kImplemented);
 
 dword_result_t RtlCompareString(lpstring_t string_1, lpstring_t string_2,
                                 dword_t case_insensitive) {
@@ -115,7 +115,7 @@ dword_result_t RtlCompareString(lpstring_t string_1, lpstring_t string_2,
 
   return ret;
 }
-DECLARE_XBOXKRNL_EXPORT(RtlCompareString, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlCompareString, kNone, kImplemented);
 
 dword_result_t RtlCompareStringN(lpstring_t string_1, dword_t string_1_len,
                                  lpstring_t string_2, dword_t string_2_len,
@@ -136,9 +136,9 @@ dword_result_t RtlCompareStringN(lpstring_t string_1, dword_t string_1_len,
 
   return ret;
 }
-DECLARE_XBOXKRNL_EXPORT(RtlCompareStringN, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlCompareStringN, kNone, kImplemented);
 
-// http://msdn.microsoft.com/en-us/library/ff561918
+// https://msdn.microsoft.com/en-us/library/ff561918
 void RtlInitAnsiString(pointer_t<X_ANSI_STRING> destination,
                        lpstring_t source) {
   if (source) {
@@ -151,9 +151,9 @@ void RtlInitAnsiString(pointer_t<X_ANSI_STRING> destination,
 
   destination->pointer = source.guest_address();
 }
-DECLARE_XBOXKRNL_EXPORT(RtlInitAnsiString, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlInitAnsiString, kNone, kImplemented);
 
-// http://msdn.microsoft.com/en-us/library/ff561899
+// https://msdn.microsoft.com/en-us/library/ff561899
 void RtlFreeAnsiString(pointer_t<X_ANSI_STRING> string) {
   if (string->pointer) {
     kernel_memory()->SystemHeapFree(string->pointer);
@@ -161,9 +161,9 @@ void RtlFreeAnsiString(pointer_t<X_ANSI_STRING> string) {
 
   string->reset();
 }
-DECLARE_XBOXKRNL_EXPORT(RtlFreeAnsiString, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlFreeAnsiString, kNone, kImplemented);
 
-// http://msdn.microsoft.com/en-us/library/ff561934
+// https://msdn.microsoft.com/en-us/library/ff561934
 void RtlInitUnicodeString(pointer_t<X_UNICODE_STRING> destination,
                           lpwstring_t source) {
   if (source) {
@@ -174,9 +174,9 @@ void RtlInitUnicodeString(pointer_t<X_UNICODE_STRING> destination,
     destination->reset();
   }
 }
-DECLARE_XBOXKRNL_EXPORT(RtlInitUnicodeString, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlInitUnicodeString, kNone, kImplemented);
 
-// http://msdn.microsoft.com/en-us/library/ff561903
+// https://msdn.microsoft.com/en-us/library/ff561903
 void RtlFreeUnicodeString(pointer_t<X_UNICODE_STRING> string) {
   if (string->pointer) {
     kernel_memory()->SystemHeapFree(string->pointer);
@@ -184,9 +184,43 @@ void RtlFreeUnicodeString(pointer_t<X_UNICODE_STRING> string) {
 
   string->reset();
 }
-DECLARE_XBOXKRNL_EXPORT(RtlFreeUnicodeString, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlFreeUnicodeString, kNone, kImplemented);
 
-// http://msdn.microsoft.com/en-us/library/ff562969
+void RtlCopyString(pointer_t<X_ANSI_STRING> destination,
+                   pointer_t<X_ANSI_STRING> source) {
+  if (!source) {
+    destination->length = 0;
+    return;
+  }
+
+  auto length = std::min(destination->maximum_length, source->length);
+  if (length > 0) {
+    auto dst_buf = kernel_memory()->TranslateVirtual(destination->pointer);
+    auto src_buf = kernel_memory()->TranslateVirtual(source->pointer);
+    std::memcpy(dst_buf, src_buf, length);
+  }
+  destination->length = length;
+}
+DECLARE_XBOXKRNL_EXPORT1(RtlCopyString, kNone, kImplemented);
+
+void RtlCopyUnicodeString(pointer_t<X_UNICODE_STRING> destination,
+                          pointer_t<X_UNICODE_STRING> source) {
+  if (!source) {
+    destination->length = 0;
+    return;
+  }
+
+  auto length = std::min(destination->maximum_length, source->length);
+  if (length > 0) {
+    auto dst_buf = kernel_memory()->TranslateVirtual(destination->pointer);
+    auto src_buf = kernel_memory()->TranslateVirtual(source->pointer);
+    std::memcpy(dst_buf, src_buf, length * 2);
+  }
+  destination->length = length;
+}
+DECLARE_XBOXKRNL_EXPORT1(RtlCopyUnicodeString, kNone, kImplemented);
+
+// https://msdn.microsoft.com/en-us/library/ff562969
 dword_result_t RtlUnicodeStringToAnsiString(
     pointer_t<X_ANSI_STRING> destination_ptr,
     pointer_t<X_UNICODE_STRING> source_ptr, dword_t alloc_dest) {
@@ -228,7 +262,7 @@ dword_result_t RtlUnicodeStringToAnsiString(
   }
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(RtlUnicodeStringToAnsiString, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlUnicodeStringToAnsiString, kNone, kImplemented);
 
 // https://msdn.microsoft.com/en-us/library/ff553113
 dword_result_t RtlMultiByteToUnicodeN(lpword_t destination_ptr,
@@ -252,8 +286,8 @@ dword_result_t RtlMultiByteToUnicodeN(lpword_t destination_ptr,
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(RtlMultiByteToUnicodeN,
-                        ExportTag::kImplemented | ExportTag::kSketchy);
+DECLARE_XBOXKRNL_EXPORT3(RtlMultiByteToUnicodeN, kNone, kImplemented,
+                         kHighFrequency, kSketchy);
 
 // https://msdn.microsoft.com/en-us/library/ff553261
 dword_result_t RtlUnicodeToMultiByteN(pointer_t<uint8_t> destination_ptr,
@@ -275,8 +309,8 @@ dword_result_t RtlUnicodeToMultiByteN(pointer_t<uint8_t> destination_ptr,
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(RtlUnicodeToMultiByteN,
-                        ExportTag::kImplemented | ExportTag::kSketchy);
+DECLARE_XBOXKRNL_EXPORT3(RtlUnicodeToMultiByteN, kNone, kImplemented,
+                         kHighFrequency, kSketchy);
 
 pointer_result_t RtlImageXexHeaderField(pointer_t<xex2_header> xex_header,
                                         dword_t field_dword) {
@@ -288,7 +322,7 @@ pointer_result_t RtlImageXexHeaderField(pointer_t<xex2_header> xex_header,
 
   return field_value;
 }
-DECLARE_XBOXKRNL_EXPORT(RtlImageXexHeaderField, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlImageXexHeaderField, kNone, kImplemented);
 
 // Unfortunately the Windows RTL_CRITICAL_SECTION object is bigger than the one
 // on the 360 (32b vs. 28b). This means that we can't do in-place splatting of
@@ -300,9 +334,10 @@ DECLARE_XBOXKRNL_EXPORT(RtlImageXexHeaderField, ExportTag::kImplemented);
 // into guest memory, as it should be opaque and so long as our size is right
 // the user code will never know.
 //
-// Ref: http://msdn.microsoft.com/en-us/magazine/cc164040.aspx
 // Ref:
-// http://svn.reactos.org/svn/reactos/trunk/reactos/lib/rtl/critical.c?view=markup
+// https://web.archive.org/web/20161214022602/https://msdn.microsoft.com/en-us/magazine/cc164040.aspx
+// Ref:
+// https://github.com/reactos/reactos/blob/master/sdk/lib/rtl/critical.c
 
 // This structure tries to match the one on the 360 as best I can figure out.
 // Unfortunately some games have the critical sections pre-initialized in
@@ -330,7 +365,7 @@ void xeRtlInitializeCriticalSection(X_RTL_CRITICAL_SECTION* cs,
 void RtlInitializeCriticalSection(pointer_t<X_RTL_CRITICAL_SECTION> cs) {
   xeRtlInitializeCriticalSection(cs, cs.guest_address());
 }
-DECLARE_XBOXKRNL_EXPORT(RtlInitializeCriticalSection, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlInitializeCriticalSection, kNone, kImplemented);
 
 X_STATUS xeRtlInitializeCriticalSectionAndSpinCount(X_RTL_CRITICAL_SECTION* cs,
                                                     uint32_t cs_ptr,
@@ -357,8 +392,8 @@ dword_result_t RtlInitializeCriticalSectionAndSpinCount(
   return xeRtlInitializeCriticalSectionAndSpinCount(cs, cs.guest_address(),
                                                     spin_count);
 }
-DECLARE_XBOXKRNL_EXPORT(RtlInitializeCriticalSectionAndSpinCount,
-                        ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlInitializeCriticalSectionAndSpinCount, kNone,
+                         kImplemented);
 
 void RtlEnterCriticalSection(pointer_t<X_RTL_CRITICAL_SECTION> cs) {
   uint32_t cur_thread = XThread::GetCurrentThread()->guest_object();
@@ -383,16 +418,16 @@ void RtlEnterCriticalSection(pointer_t<X_RTL_CRITICAL_SECTION> cs) {
 
   if (xe::atomic_inc(&cs->lock_count) != 0) {
     // Create a full waiter.
-    KeWaitForSingleObject(reinterpret_cast<void*>(cs.host_address()), 8, 0, 0,
-                          nullptr);
+    xeKeWaitForSingleObject(reinterpret_cast<void*>(cs.host_address()), 8, 0, 0,
+                            nullptr);
   }
 
   assert_true(cs->owning_thread == 0);
   cs->owning_thread = cur_thread;
   cs->recursion_count = 1;
 }
-DECLARE_XBOXKRNL_EXPORT(RtlEnterCriticalSection,
-                        ExportTag::kImplemented | ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(RtlEnterCriticalSection, kNone, kImplemented,
+                         kHighFrequency);
 
 dword_result_t RtlTryEnterCriticalSection(
     pointer_t<X_RTL_CRITICAL_SECTION> cs) {
@@ -413,8 +448,8 @@ dword_result_t RtlTryEnterCriticalSection(
   // Failed to acquire lock.
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(RtlTryEnterCriticalSection,
-                        ExportTag::kImplemented | ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(RtlTryEnterCriticalSection, kNone, kImplemented,
+                         kHighFrequency);
 
 void RtlLeaveCriticalSection(pointer_t<X_RTL_CRITICAL_SECTION> cs) {
   assert_true(cs->owning_thread == XThread::GetCurrentThread()->guest_object());
@@ -432,11 +467,11 @@ void RtlLeaveCriticalSection(pointer_t<X_RTL_CRITICAL_SECTION> cs) {
   cs->owning_thread = 0;
   if (xe::atomic_dec(&cs->lock_count) != -1) {
     // There were waiters - wake one of them.
-    KeSetEvent(reinterpret_cast<X_KEVENT*>(cs.host_address()), 1, 0);
+    xeKeSetEvent(reinterpret_cast<X_KEVENT*>(cs.host_address()), 1, 0);
   }
 }
-DECLARE_XBOXKRNL_EXPORT(RtlLeaveCriticalSection,
-                        ExportTag::kImplemented | ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(RtlLeaveCriticalSection, kNone, kImplemented,
+                         kHighFrequency);
 
 struct X_TIME_FIELDS {
   xe::be<uint16_t> year;
@@ -466,7 +501,7 @@ void RtlTimeToTimeFields(lpqword_t time_ptr,
   time_fields_ptr->milliseconds = time_ms % 1000;
   time_fields_ptr->weekday = tm->tm_wday;
 }
-DECLARE_XBOXKRNL_EXPORT(RtlTimeToTimeFields, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlTimeToTimeFields, kNone, kImplemented);
 
 dword_result_t RtlTimeFieldsToTime(pointer_t<X_TIME_FIELDS> time_fields_ptr,
                                    lpqword_t time_ptr) {
@@ -488,7 +523,7 @@ dword_result_t RtlTimeFieldsToTime(pointer_t<X_TIME_FIELDS> time_fields_ptr,
   *time_ptr = time;
   return 1;
 }
-DECLARE_XBOXKRNL_EXPORT(RtlTimeFieldsToTime, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(RtlTimeFieldsToTime, kNone, kImplemented);
 
 void RegisterRtlExports(xe::cpu::ExportResolver* export_resolver,
                         KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_strings.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_strings.cc
index 2067f29e6..aa1bbf245 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_strings.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_strings.cc
@@ -1009,6 +1009,46 @@ SHIM_CALL _vsnprintf_shim(PPCContext* ppc_context, KernelState* kernel_state) {
   SHIM_SET_RETURN_32(count);
 }
 
+// https://msdn.microsoft.com/en-us/library/1kt27hek.aspx
+SHIM_CALL _vsnwprintf_shim(PPCContext* ppc_context, KernelState* kernel_state) {
+  uint32_t buffer_ptr = SHIM_GET_ARG_32(0);
+  int32_t buffer_count = SHIM_GET_ARG_32(1);
+  uint32_t format_ptr = SHIM_GET_ARG_32(2);
+  uint32_t arg_ptr = SHIM_GET_ARG_32(3);
+
+  XELOGD("_vsnwprintf(%08X, %i, %08X, %08X)", buffer_ptr, buffer_count,
+         format_ptr, arg_ptr);
+
+  if (buffer_ptr == 0 || buffer_count <= 0 || format_ptr == 0) {
+    SHIM_SET_RETURN_32(-1);
+    return;
+  }
+
+  auto buffer = (uint16_t*)SHIM_MEM_ADDR(buffer_ptr);
+  auto format = (const uint16_t*)SHIM_MEM_ADDR(format_ptr);
+
+  ArrayArgList args(ppc_context, arg_ptr);
+  WideStringFormatData data(format);
+
+  int32_t count = format_core(ppc_context, data, args, true);
+  if (count < 0) {
+    // Error.
+    if (buffer_count > 0) {
+      buffer[0] = '\0';  // write a null, just to be safe
+    }
+  } else if (count <= buffer_count) {
+    // Fit within the buffer.
+    xe::copy_and_swap(buffer, (uint16_t*)data.wstr().c_str(), count);
+    if (count < buffer_count) {
+      buffer[count] = '\0';
+    }
+  } else {
+    // Overflowed buffer. We still return the count we would have written.
+    xe::copy_and_swap(buffer, (uint16_t*)data.wstr().c_str(), buffer_count);
+  }
+  SHIM_SET_RETURN_32(count);
+}
+
 // https://msdn.microsoft.com/en-us/library/28d5ce15.aspx
 SHIM_CALL vsprintf_shim(PPCContext* ppc_context, KernelState* kernel_state) {
   uint32_t buffer_ptr = SHIM_GET_ARG_32(0);
@@ -1100,6 +1140,7 @@ void RegisterStringExports(xe::cpu::ExportResolver* export_resolver,
   SHIM_SET_MAPPING("xboxkrnl.exe", vsprintf, state);
   SHIM_SET_MAPPING("xboxkrnl.exe", _vscwprintf, state);
   SHIM_SET_MAPPING("xboxkrnl.exe", vswprintf, state);
+  SHIM_SET_MAPPING("xboxkrnl.exe", _vsnwprintf, state);
 }
 
 }  // namespace xboxkrnl
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_threading.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_threading.cc
index 46d11acad..fc220404e 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_threading.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_threading.cc
@@ -93,20 +93,11 @@ object_ref<T> LookupNamedObject(KernelState* kernel_state,
   return nullptr;
 }
 
-SHIM_CALL ExCreateThread_shim(PPCContext* ppc_context,
-                              KernelState* kernel_state) {
-  uint32_t handle_ptr = SHIM_GET_ARG_32(0);
-  uint32_t stack_size = SHIM_GET_ARG_32(1);
-  uint32_t thread_id_ptr = SHIM_GET_ARG_32(2);
-  uint32_t xapi_thread_startup = SHIM_GET_ARG_32(3);
-  uint32_t start_address = SHIM_GET_ARG_32(4);
-  uint32_t start_context = SHIM_GET_ARG_32(5);
-  uint32_t creation_flags = SHIM_GET_ARG_32(6);
-
-  XELOGD("ExCreateThread(%.8X, %d, %.8X, %.8X, %.8X, %.8X, %.8X)", handle_ptr,
-         stack_size, thread_id_ptr, xapi_thread_startup, start_address,
-         start_context, creation_flags);
-
+dword_result_t ExCreateThread(lpdword_t handle_ptr, dword_t stack_size,
+                              lpdword_t thread_id_ptr,
+                              dword_t xapi_thread_startup,
+                              lpvoid_t start_address, lpvoid_t start_context,
+                              dword_t creation_flags) {
   // http://jafile.com/uploads/scoop/main.cpp.txt
   // DWORD
   // LPHANDLE Handle,
@@ -118,103 +109,87 @@ SHIM_CALL ExCreateThread_shim(PPCContext* ppc_context,
   // DWORD    CreationFlags // 0x80?
 
   // Inherit default stack size
-  if (stack_size == 0) {
-    stack_size = kernel_state->GetExecutableModule()->stack_size();
+  uint32_t actual_stack_size = stack_size;
+
+  if (actual_stack_size == 0) {
+    actual_stack_size = kernel_state()->GetExecutableModule()->stack_size();
   }
 
   // Stack must be aligned to 16kb pages
-  stack_size = std::max((uint32_t)0x4000, ((stack_size + 0xFFF) & 0xFFFFF000));
+  actual_stack_size =
+      std::max((uint32_t)0x4000, ((actual_stack_size + 0xFFF) & 0xFFFFF000));
 
   auto thread = object_ref<XThread>(
-      new XThread(kernel_state, stack_size, xapi_thread_startup, start_address,
-                  start_context, creation_flags, true));
+      new XThread(kernel_state(), actual_stack_size, xapi_thread_startup,
+                  start_address.guest_address(), start_context.guest_address(),
+                  creation_flags, true));
 
   X_STATUS result = thread->Create();
   if (XFAILED(result)) {
     // Failed!
     XELOGE("Thread creation failed: %.8X", result);
-    SHIM_SET_RETURN_32(result);
-    return;
+    return result;
   }
 
   if (XSUCCEEDED(result)) {
     if (handle_ptr) {
       if (creation_flags & 0x80) {
-        SHIM_SET_MEM_32(handle_ptr, thread->guest_object());
+        *handle_ptr = thread->guest_object();
       } else {
-        SHIM_SET_MEM_32(handle_ptr, thread->handle());
+        thread->RetainHandle();
+        *handle_ptr = thread->handle();
       }
     }
     if (thread_id_ptr) {
-      SHIM_SET_MEM_32(thread_id_ptr, thread->thread_id());
+      *thread_id_ptr = thread->thread_id();
     }
   }
-  SHIM_SET_RETURN_32(result);
+  return result;
 }
+DECLARE_XBOXKRNL_EXPORT1(ExCreateThread, kThreading, kImplemented);
 
-SHIM_CALL ExTerminateThread_shim(PPCContext* ppc_context,
-                                 KernelState* kernel_state) {
-  uint32_t exit_code = SHIM_GET_ARG_32(0);
-
-  XELOGD("ExTerminateThread(%d)", exit_code);
-
+dword_result_t ExTerminateThread(dword_t exit_code) {
   XThread* thread = XThread::GetCurrentThread();
 
   // NOTE: this kills us right now. We won't return from it.
-  X_STATUS result = thread->Exit(exit_code);
-  SHIM_SET_RETURN_32(result);
+  return thread->Exit(exit_code);
 }
+DECLARE_XBOXKRNL_EXPORT1(ExTerminateThread, kThreading, kImplemented);
 
-SHIM_CALL NtResumeThread_shim(PPCContext* ppc_context,
-                              KernelState* kernel_state) {
-  uint32_t handle = SHIM_GET_ARG_32(0);
-  uint32_t suspend_count_ptr = SHIM_GET_ARG_32(1);
-
-  XELOGD("NtResumeThread(%.8X, %.8X)", handle, suspend_count_ptr);
-
+dword_result_t NtResumeThread(dword_t handle, lpdword_t suspend_count_ptr) {
   X_RESULT result = X_STATUS_INVALID_HANDLE;
   uint32_t suspend_count = 0;
 
-  auto thread = kernel_state->object_table()->LookupObject<XThread>(handle);
+  auto thread = kernel_state()->object_table()->LookupObject<XThread>(handle);
   if (thread) {
     result = thread->Resume(&suspend_count);
   }
   if (suspend_count_ptr) {
-    SHIM_SET_MEM_32(suspend_count_ptr, suspend_count);
+    *suspend_count_ptr = suspend_count;
   }
 
-  SHIM_SET_RETURN_32(result);
+  return result;
 }
+DECLARE_XBOXKRNL_EXPORT1(NtResumeThread, kThreading, kImplemented);
 
-SHIM_CALL KeResumeThread_shim(PPCContext* ppc_context,
-                              KernelState* kernel_state) {
-  uint32_t thread_ptr = SHIM_GET_ARG_32(0);
-
-  XELOGD("KeResumeThread(%.8X)", thread_ptr);
-
+dword_result_t KeResumeThread(lpvoid_t thread_ptr) {
   X_STATUS result = X_STATUS_SUCCESS;
-  auto thread = XObject::GetNativeObject<XThread>(kernel_state,
-                                                  SHIM_MEM_ADDR(thread_ptr));
+  auto thread = XObject::GetNativeObject<XThread>(kernel_state(), thread_ptr);
   if (thread) {
     result = thread->Resume();
   } else {
     result = X_STATUS_INVALID_HANDLE;
   }
 
-  SHIM_SET_RETURN_32(result);
+  return result;
 }
+DECLARE_XBOXKRNL_EXPORT1(KeResumeThread, kThreading, kImplemented);
 
-SHIM_CALL NtSuspendThread_shim(PPCContext* ppc_context,
-                               KernelState* kernel_state) {
-  uint32_t handle = SHIM_GET_ARG_32(0);
-  uint32_t suspend_count_ptr = SHIM_GET_ARG_32(1);
-
-  XELOGD("NtSuspendThread(%.8X, %.8X)", handle, suspend_count_ptr);
-
+dword_result_t NtSuspendThread(dword_t handle, lpdword_t suspend_count_ptr) {
   X_RESULT result = X_STATUS_SUCCESS;
   uint32_t suspend_count = 0;
 
-  auto thread = kernel_state->object_table()->LookupObject<XThread>(handle);
+  auto thread = kernel_state()->object_table()->LookupObject<XThread>(handle);
   if (thread) {
     result = thread->Suspend(&suspend_count);
   } else {
@@ -222,11 +197,12 @@ SHIM_CALL NtSuspendThread_shim(PPCContext* ppc_context,
   }
 
   if (suspend_count_ptr) {
-    SHIM_SET_MEM_32(suspend_count_ptr, suspend_count);
+    *suspend_count_ptr = suspend_count;
   }
 
-  SHIM_SET_RETURN_32(result);
+  return result;
 }
+DECLARE_XBOXKRNL_EXPORT1(NtSuspendThread, kThreading, kImplemented);
 
 void KeSetCurrentStackPointers(lpvoid_t stack_ptr,
                                pointer_t<X_KTHREAD> cur_thread,
@@ -243,107 +219,74 @@ void KeSetCurrentStackPointers(lpvoid_t stack_ptr,
 
   // TODO: Do we need to set the stack info on cur_thread?
 }
-DECLARE_XBOXKRNL_EXPORT(KeSetCurrentStackPointers,
-                        ExportTag::kThreading | ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(KeSetCurrentStackPointers, kThreading, kImplemented);
 
-SHIM_CALL KeSetAffinityThread_shim(PPCContext* ppc_context,
-                                   KernelState* kernel_state) {
-  uint32_t thread_ptr = SHIM_GET_ARG_32(0);
-  uint32_t affinity = SHIM_GET_ARG_32(1);
-
-  XELOGD("KeSetAffinityThread(%.8X, %.8X)", thread_ptr, affinity);
-
-  auto thread = XObject::GetNativeObject<XThread>(kernel_state,
-                                                  SHIM_MEM_ADDR(thread_ptr));
+dword_result_t KeSetAffinityThread(lpvoid_t thread_ptr, dword_t affinity) {
+  auto thread = XObject::GetNativeObject<XThread>(kernel_state(), thread_ptr);
   if (thread) {
     thread->SetAffinity(affinity);
   }
 
-  SHIM_SET_RETURN_32(affinity);
+  return (uint32_t)affinity;
 }
+DECLARE_XBOXKRNL_EXPORT1(KeSetAffinityThread, kThreading, kImplemented);
 
-SHIM_CALL KeQueryBasePriorityThread_shim(PPCContext* ppc_context,
-                                         KernelState* kernel_state) {
-  uint32_t thread_ptr = SHIM_GET_ARG_32(0);
-
-  XELOGD("KeQueryBasePriorityThread(%.8X)", thread_ptr);
-
+dword_result_t KeQueryBasePriorityThread(lpvoid_t thread_ptr) {
   int32_t priority = 0;
 
-  auto thread = XObject::GetNativeObject<XThread>(kernel_state,
-                                                  SHIM_MEM_ADDR(thread_ptr));
+  auto thread = XObject::GetNativeObject<XThread>(kernel_state(), thread_ptr);
   if (thread) {
     priority = thread->QueryPriority();
   }
 
-  SHIM_SET_RETURN_32(priority);
+  return priority;
 }
+DECLARE_XBOXKRNL_EXPORT1(KeQueryBasePriorityThread, kThreading, kImplemented);
 
-SHIM_CALL KeSetBasePriorityThread_shim(PPCContext* ppc_context,
-                                       KernelState* kernel_state) {
-  uint32_t thread_ptr = SHIM_GET_ARG_32(0);
-  uint32_t increment = SHIM_GET_ARG_32(1);
-
-  XELOGD("KeSetBasePriorityThread(%.8X, %.8X)", thread_ptr, increment);
-
+dword_result_t KeSetBasePriorityThread(lpvoid_t thread_ptr, dword_t increment) {
   int32_t prev_priority = 0;
-  auto thread = XObject::GetNativeObject<XThread>(kernel_state,
-                                                  SHIM_MEM_ADDR(thread_ptr));
+  auto thread = XObject::GetNativeObject<XThread>(kernel_state(), thread_ptr);
 
   if (thread) {
     prev_priority = thread->QueryPriority();
     thread->SetPriority(increment);
   }
 
-  SHIM_SET_RETURN_32(prev_priority);
+  return prev_priority;
 }
+DECLARE_XBOXKRNL_EXPORT1(KeSetBasePriorityThread, kThreading, kImplemented);
 
-SHIM_CALL KeSetDisableBoostThread_shim(PPCContext* ppc_context,
-                                       KernelState* kernel_state) {
-  uint32_t thread_ptr = SHIM_GET_ARG_32(0);
-  uint32_t disabled = SHIM_GET_ARG_32(1);
-
-  XELOGD("KeSetDisableBoostThread(%.8X, %.8X)", thread_ptr, disabled);
-
-  auto thread = XObject::GetNativeObject<XThread>(kernel_state,
-                                                  SHIM_MEM_ADDR(thread_ptr));
+dword_result_t KeSetDisableBoostThread(lpvoid_t thread_ptr, dword_t disabled) {
+  auto thread = XObject::GetNativeObject<XThread>(kernel_state(), thread_ptr);
   if (thread) {
     // Uhm?
   }
 
-  SHIM_SET_RETURN_32(0);
+  return 0;
 }
+DECLARE_XBOXKRNL_EXPORT1(KeSetDisableBoostThread, kThreading, kImplemented);
 
-SHIM_CALL KeGetCurrentProcessType_shim(PPCContext* ppc_context,
-                                       KernelState* kernel_state) {
-  // XELOGD(
-  //     "KeGetCurrentProcessType()");
-
-  // DWORD
-
-  SHIM_SET_RETURN_32(kernel_state->process_type());
+dword_result_t KeGetCurrentProcessType() {
+  return kernel_state()->process_type();
 }
+DECLARE_XBOXKRNL_EXPORT2(KeGetCurrentProcessType, kThreading, kImplemented,
+                         kHighFrequency);
 
-SHIM_CALL KeSetCurrentProcessType_shim(PPCContext* ppc_context,
-                                       KernelState* kernel_state) {
-  uint32_t type = SHIM_GET_ARG_32(0);
+void KeSetCurrentProcessType(dword_t type) {
   // One of X_PROCTYPE_?
 
-  XELOGD("KeSetCurrentProcessType(%d)", type);
-
   assert_true(type <= 2);
 
-  kernel_state->set_process_type(type);
+  kernel_state()->set_process_type(type);
 }
+DECLARE_XBOXKRNL_EXPORT1(KeSetCurrentProcessType, kThreading, kImplemented);
 
-SHIM_CALL KeQueryPerformanceFrequency_shim(PPCContext* ppc_context,
-                                           KernelState* kernel_state) {
-  // XELOGD(
-  //     "KeQueryPerformanceFrequency()");
-
+dword_result_t KeQueryPerformanceFrequency() {
   uint64_t result = Clock::guest_tick_frequency();
-  SHIM_SET_RETURN_32(result);
+  return static_cast<uint32_t>(result);
 }
+DECLARE_XBOXKRNL_EXPORT2(KeQueryPerformanceFrequency, kThreading, kImplemented,
+                         kHighFrequency);
 
 dword_result_t KeDelayExecutionThread(dword_t processor_mode, dword_t alertable,
                                       lpqword_t interval_ptr) {
@@ -352,40 +295,35 @@ dword_result_t KeDelayExecutionThread(dword_t processor_mode, dword_t alertable,
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(KeDelayExecutionThread,
-                        ExportTag::kImplemented | ExportTag::kThreading |
-                            ExportTag::kHighFrequency | ExportTag::kBlocking);
+DECLARE_XBOXKRNL_EXPORT3(KeDelayExecutionThread, kThreading, kImplemented,
+                         kBlocking, kHighFrequency);
 
-SHIM_CALL NtYieldExecution_shim(PPCContext* ppc_context,
-                                KernelState* kernel_state) {
-  // XELOGD("NtYieldExecution()");
+dword_result_t NtYieldExecution() {
   auto thread = XThread::GetCurrentThread();
   thread->Delay(0, 0, 0);
-  SHIM_SET_RETURN_32(0);
+  return 0;
 }
+DECLARE_XBOXKRNL_EXPORT2(NtYieldExecution, kThreading, kImplemented,
+                         kHighFrequency);
 
-SHIM_CALL KeQuerySystemTime_shim(PPCContext* ppc_context,
-                                 KernelState* kernel_state) {
-  uint32_t time_ptr = SHIM_GET_ARG_32(0);
-
-  XELOGD("KeQuerySystemTime(%.8X)", time_ptr);
-
+void KeQuerySystemTime(lpqword_t time_ptr) {
   uint64_t time = Clock::QueryGuestSystemTime();
   if (time_ptr) {
-    SHIM_SET_MEM_64(time_ptr, time);
+    *time_ptr = time;
   }
 }
+DECLARE_XBOXKRNL_EXPORT1(KeQuerySystemTime, kThreading, kImplemented);
 
-// http://msdn.microsoft.com/en-us/library/ms686801
+// https://msdn.microsoft.com/en-us/library/ms686801
 dword_result_t KeTlsAlloc() {
   uint32_t slot = kernel_state()->AllocateTLS();
   XThread::GetCurrentThread()->SetTLSValue(slot, 0);
 
   return slot;
 }
-DECLARE_XBOXKRNL_EXPORT(KeTlsAlloc, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(KeTlsAlloc, kThreading, kImplemented);
 
-// http://msdn.microsoft.com/en-us/library/ms686804
+// https://msdn.microsoft.com/en-us/library/ms686804
 dword_result_t KeTlsFree(dword_t tls_index) {
   if (tls_index == X_TLS_OUT_OF_INDEXES) {
     return 0;
@@ -394,9 +332,9 @@ dword_result_t KeTlsFree(dword_t tls_index) {
   kernel_state()->FreeTLS(tls_index);
   return 1;
 }
-DECLARE_XBOXKRNL_EXPORT(KeTlsFree, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(KeTlsFree, kThreading, kImplemented);
 
-// http://msdn.microsoft.com/en-us/library/ms686812
+// https://msdn.microsoft.com/en-us/library/ms686812
 dword_result_t KeTlsGetValue(dword_t tls_index) {
   // xboxkrnl doesn't actually have an error branch - it always succeeds, even
   // if it overflows the TLS.
@@ -407,10 +345,10 @@ dword_result_t KeTlsGetValue(dword_t tls_index) {
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(KeTlsGetValue,
-                        ExportTag::kImplemented | ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(KeTlsGetValue, kThreading, kImplemented,
+                         kHighFrequency);
 
-// http://msdn.microsoft.com/en-us/library/ms686818
+// https://msdn.microsoft.com/en-us/library/ms686818
 dword_result_t KeTlsSetValue(dword_t tls_index, dword_t tls_value) {
   // xboxkrnl doesn't actually have an error branch - it always succeeds, even
   // if it overflows the TLS.
@@ -420,7 +358,7 @@ dword_result_t KeTlsSetValue(dword_t tls_index, dword_t tls_value) {
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(KeTlsSetValue, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(KeTlsSetValue, kThreading, kImplemented);
 
 void KeInitializeEvent(pointer_t<X_KEVENT> event_ptr, dword_t event_type,
                        dword_t initial_state) {
@@ -434,11 +372,9 @@ void KeInitializeEvent(pointer_t<X_KEVENT> event_ptr, dword_t event_type,
     return;
   }
 }
-DECLARE_XBOXKRNL_EXPORT(KeInitializeEvent,
-                        ExportTag::kImplemented | ExportTag::kThreading);
+DECLARE_XBOXKRNL_EXPORT1(KeInitializeEvent, kThreading, kImplemented);
 
-dword_result_t KeSetEvent(pointer_t<X_KEVENT> event_ptr, dword_t increment,
-                          dword_t wait) {
+uint32_t xeKeSetEvent(X_KEVENT* event_ptr, uint32_t increment, uint32_t wait) {
   auto ev = XObject::GetNativeObject<XEvent>(kernel_state(), event_ptr);
   if (!ev) {
     assert_always();
@@ -447,9 +383,12 @@ dword_result_t KeSetEvent(pointer_t<X_KEVENT> event_ptr, dword_t increment,
 
   return ev->Set(increment, !!wait);
 }
-DECLARE_XBOXKRNL_EXPORT(KeSetEvent, ExportTag::kImplemented |
-                                        ExportTag::kThreading |
-                                        ExportTag::kHighFrequency);
+
+dword_result_t KeSetEvent(pointer_t<X_KEVENT> event_ptr, dword_t increment,
+                          dword_t wait) {
+  return xeKeSetEvent(event_ptr, increment, wait);
+}
+DECLARE_XBOXKRNL_EXPORT2(KeSetEvent, kThreading, kImplemented, kHighFrequency);
 
 dword_result_t KePulseEvent(pointer_t<X_KEVENT> event_ptr, dword_t increment,
                             dword_t wait) {
@@ -461,9 +400,8 @@ dword_result_t KePulseEvent(pointer_t<X_KEVENT> event_ptr, dword_t increment,
 
   return ev->Pulse(increment, !!wait);
 }
-DECLARE_XBOXKRNL_EXPORT(KePulseEvent, ExportTag::kImplemented |
-                                          ExportTag::kThreading |
-                                          ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(KePulseEvent, kThreading, kImplemented,
+                         kHighFrequency);
 
 dword_result_t KeResetEvent(pointer_t<X_KEVENT> event_ptr) {
   auto ev = XObject::GetNativeObject<XEvent>(kernel_state(), event_ptr);
@@ -474,8 +412,7 @@ dword_result_t KeResetEvent(pointer_t<X_KEVENT> event_ptr) {
 
   return ev->Reset();
 }
-DECLARE_XBOXKRNL_EXPORT(KeResetEvent,
-                        ExportTag::kImplemented | ExportTag::kThreading);
+DECLARE_XBOXKRNL_EXPORT1(KeResetEvent, kThreading, kImplemented);
 
 dword_result_t NtCreateEvent(lpdword_t handle_ptr,
                              pointer_t<X_OBJECT_ATTRIBUTES> obj_attributes_ptr,
@@ -508,10 +445,9 @@ dword_result_t NtCreateEvent(lpdword_t handle_ptr,
   }
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(NtCreateEvent,
-                        ExportTag::kImplemented | ExportTag::kThreading);
+DECLARE_XBOXKRNL_EXPORT1(NtCreateEvent, kThreading, kImplemented);
 
-dword_result_t NtSetEvent(dword_t handle, lpdword_t previous_state_ptr) {
+uint32_t xeNtSetEvent(uint32_t handle, xe::be<uint32_t>* previous_state_ptr) {
   X_STATUS result = X_STATUS_SUCCESS;
 
   auto ev = kernel_state()->object_table()->LookupObject<XEvent>(handle);
@@ -526,9 +462,11 @@ dword_result_t NtSetEvent(dword_t handle, lpdword_t previous_state_ptr) {
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(NtSetEvent, ExportTag::kImplemented |
-                                        ExportTag::kThreading |
-                                        ExportTag::kHighFrequency);
+
+dword_result_t NtSetEvent(dword_t handle, lpdword_t previous_state_ptr) {
+  return xeNtSetEvent(handle, previous_state_ptr);
+}
+DECLARE_XBOXKRNL_EXPORT2(NtSetEvent, kThreading, kImplemented, kHighFrequency);
 
 dword_result_t NtPulseEvent(dword_t handle, lpdword_t previous_state_ptr) {
   X_STATUS result = X_STATUS_SUCCESS;
@@ -545,11 +483,10 @@ dword_result_t NtPulseEvent(dword_t handle, lpdword_t previous_state_ptr) {
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(NtPulseEvent, ExportTag::kImplemented |
-                                          ExportTag::kThreading |
-                                          ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(NtPulseEvent, kThreading, kImplemented,
+                         kHighFrequency);
 
-dword_result_t NtClearEvent(dword_t handle) {
+uint32_t xeNtClearEvent(uint32_t handle) {
   X_STATUS result = X_STATUS_SUCCESS;
 
   auto ev = kernel_state()->object_table()->LookupObject<XEvent>(handle);
@@ -561,9 +498,10 @@ dword_result_t NtClearEvent(dword_t handle) {
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(NtClearEvent, ExportTag::kImplemented |
-                                          ExportTag::kThreading |
-                                          ExportTag::kHighFrequency);
+
+dword_result_t NtClearEvent(dword_t handle) { return xeNtClearEvent(handle); }
+DECLARE_XBOXKRNL_EXPORT2(NtClearEvent, kThreading, kImplemented,
+                         kHighFrequency);
 
 // https://msdn.microsoft.com/en-us/library/windows/hardware/ff552150(v=vs.85).aspx
 void KeInitializeSemaphore(pointer_t<X_KSEMAPHORE> semaphore_ptr, dword_t count,
@@ -579,12 +517,10 @@ void KeInitializeSemaphore(pointer_t<X_KSEMAPHORE> semaphore_ptr, dword_t count,
     return;
   }
 }
-DECLARE_XBOXKRNL_EXPORT(KeInitializeSemaphore,
-                        ExportTag::kImplemented | ExportTag::kThreading);
+DECLARE_XBOXKRNL_EXPORT1(KeInitializeSemaphore, kThreading, kImplemented);
 
-dword_result_t KeReleaseSemaphore(pointer_t<X_KSEMAPHORE> semaphore_ptr,
-                                  dword_t increment, dword_t adjustment,
-                                  dword_t wait) {
+uint32_t xeKeReleaseSemaphore(X_KSEMAPHORE* semaphore_ptr, uint32_t increment,
+                              uint32_t adjustment, uint32_t wait) {
   auto sem =
       XObject::GetNativeObject<XSemaphore>(kernel_state(), semaphore_ptr);
   if (!sem) {
@@ -597,37 +533,34 @@ dword_result_t KeReleaseSemaphore(pointer_t<X_KSEMAPHORE> semaphore_ptr,
 
   return sem->ReleaseSemaphore(adjustment);
 }
-DECLARE_XBOXKRNL_EXPORT(KeReleaseSemaphore,
-                        ExportTag::kImplemented | ExportTag::kThreading);
 
-SHIM_CALL NtCreateSemaphore_shim(PPCContext* ppc_context,
-                                 KernelState* kernel_state) {
-  uint32_t handle_ptr = SHIM_GET_ARG_32(0);
-  uint32_t obj_attributes_ptr = SHIM_GET_ARG_32(1);
-  int32_t count = SHIM_GET_ARG_32(2);
-  int32_t limit = SHIM_GET_ARG_32(3);
-
-  XELOGD("NtCreateSemaphore(%.8X, %.8X, %d, %d)", handle_ptr,
-         obj_attributes_ptr, count, limit);
+dword_result_t KeReleaseSemaphore(pointer_t<X_KSEMAPHORE> semaphore_ptr,
+                                  dword_t increment, dword_t adjustment,
+                                  dword_t wait) {
+  return xeKeReleaseSemaphore(semaphore_ptr, increment, adjustment, wait);
+}
+DECLARE_XBOXKRNL_EXPORT1(KeReleaseSemaphore, kThreading, kImplemented);
 
+dword_result_t NtCreateSemaphore(lpdword_t handle_ptr,
+                                 lpvoid_t obj_attributes_ptr, dword_t count,
+                                 dword_t limit) {
   // Check for an existing timer with the same name.
   auto existing_object =
-      LookupNamedObject<XSemaphore>(kernel_state, obj_attributes_ptr);
+      LookupNamedObject<XSemaphore>(kernel_state(), obj_attributes_ptr);
   if (existing_object) {
     if (existing_object->type() == XObject::kTypeSemaphore) {
       if (handle_ptr) {
         existing_object->RetainHandle();
-        SHIM_SET_MEM_32(handle_ptr, existing_object->handle());
+        *handle_ptr = existing_object->handle();
       }
-      SHIM_SET_RETURN_32(X_STATUS_SUCCESS);
+      return X_STATUS_SUCCESS;
     } else {
-      SHIM_SET_RETURN_32(X_STATUS_INVALID_HANDLE);
+      return X_STATUS_INVALID_HANDLE;
     }
-    return;
   }
 
-  auto sem = object_ref<XSemaphore>(new XSemaphore(kernel_state));
-  sem->Initialize(count, limit);
+  auto sem = object_ref<XSemaphore>(new XSemaphore(kernel_state()));
+  sem->Initialize((int32_t)count, (int32_t)limit);
 
   // obj_attributes may have a name inside of it, if != NULL.
   if (obj_attributes_ptr) {
@@ -635,36 +568,32 @@ SHIM_CALL NtCreateSemaphore_shim(PPCContext* ppc_context,
   }
 
   if (handle_ptr) {
-    SHIM_SET_MEM_32(handle_ptr, sem->handle());
+    *handle_ptr = sem->handle();
   }
 
-  SHIM_SET_RETURN_32(X_STATUS_SUCCESS);
+  return X_STATUS_SUCCESS;
 }
+DECLARE_XBOXKRNL_EXPORT1(NtCreateSemaphore, kThreading, kImplemented);
 
-SHIM_CALL NtReleaseSemaphore_shim(PPCContext* ppc_context,
-                                  KernelState* kernel_state) {
-  uint32_t sem_handle = SHIM_GET_ARG_32(0);
-  int32_t release_count = SHIM_GET_ARG_32(1);
-  int32_t previous_count_ptr = SHIM_GET_ARG_32(2);
-
-  XELOGD("NtReleaseSemaphore(%.8X, %d, %.8X)", sem_handle, release_count,
-         previous_count_ptr);
-
+dword_result_t NtReleaseSemaphore(dword_t sem_handle, dword_t release_count,
+                                  lpdword_t previous_count_ptr) {
   X_STATUS result = X_STATUS_SUCCESS;
   int32_t previous_count = 0;
 
-  auto sem = kernel_state->object_table()->LookupObject<XSemaphore>(sem_handle);
+  auto sem =
+      kernel_state()->object_table()->LookupObject<XSemaphore>(sem_handle);
   if (sem) {
-    previous_count = sem->ReleaseSemaphore(release_count);
+    previous_count = sem->ReleaseSemaphore((int32_t)release_count);
   } else {
     result = X_STATUS_INVALID_HANDLE;
   }
   if (previous_count_ptr) {
-    SHIM_SET_MEM_32(previous_count_ptr, previous_count);
+    *previous_count_ptr = (uint32_t)previous_count;
   }
 
-  SHIM_SET_RETURN_32(result);
+  return result;
 }
+DECLARE_XBOXKRNL_EXPORT1(NtReleaseSemaphore, kThreading, kImplemented);
 
 dword_result_t NtCreateMutant(lpdword_t handle_out,
                               pointer_t<X_OBJECT_ATTRIBUTES> obj_attributes,
@@ -698,12 +627,9 @@ dword_result_t NtCreateMutant(lpdword_t handle_out,
 
   return X_STATUS_SUCCESS;
 }
-DECLARE_XBOXKRNL_EXPORT(NtCreateMutant, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(NtCreateMutant, kThreading, kImplemented);
 
-SHIM_CALL NtReleaseMutant_shim(PPCContext* ppc_context,
-                               KernelState* kernel_state) {
-  uint32_t mutant_handle = SHIM_GET_ARG_32(0);
-  int32_t unknown = SHIM_GET_ARG_32(1);
+dword_result_t NtReleaseMutant(dword_t mutant_handle, dword_t unknown) {
   // This doesn't seem to be supported.
   // int32_t previous_count_ptr = SHIM_GET_ARG_32(2);
 
@@ -715,49 +641,40 @@ SHIM_CALL NtReleaseMutant_shim(PPCContext* ppc_context,
   bool abandon = false;
   bool wait = false;
 
-  XELOGD("NtReleaseMutant(%.8X, %.8X)", mutant_handle, unknown);
-
   X_STATUS result = X_STATUS_SUCCESS;
 
   auto mutant =
-      kernel_state->object_table()->LookupObject<XMutant>(mutant_handle);
+      kernel_state()->object_table()->LookupObject<XMutant>(mutant_handle);
   if (mutant) {
     result = mutant->ReleaseMutant(priority_increment, abandon, wait);
   } else {
     result = X_STATUS_INVALID_HANDLE;
   }
 
-  SHIM_SET_RETURN_32(result);
+  return result;
 }
+DECLARE_XBOXKRNL_EXPORT1(NtReleaseMutant, kThreading, kImplemented);
 
-SHIM_CALL NtCreateTimer_shim(PPCContext* ppc_context,
-                             KernelState* kernel_state) {
-  uint32_t handle_ptr = SHIM_GET_ARG_32(0);
-  uint32_t obj_attributes_ptr = SHIM_GET_ARG_32(1);
-  uint32_t timer_type = SHIM_GET_ARG_32(2);
-
+dword_result_t NtCreateTimer(lpdword_t handle_ptr, lpvoid_t obj_attributes_ptr,
+                             dword_t timer_type) {
   // timer_type = NotificationTimer (0) or SynchronizationTimer (1)
 
-  XELOGD("NtCreateTimer(%.8X, %.8X, %.1X)", handle_ptr, obj_attributes_ptr,
-         timer_type);
-
   // Check for an existing timer with the same name.
   auto existing_object =
-      LookupNamedObject<XTimer>(kernel_state, obj_attributes_ptr);
+      LookupNamedObject<XTimer>(kernel_state(), obj_attributes_ptr);
   if (existing_object) {
     if (existing_object->type() == XObject::kTypeTimer) {
       if (handle_ptr) {
         existing_object->RetainHandle();
-        SHIM_SET_MEM_32(handle_ptr, existing_object->handle());
+        *handle_ptr = existing_object->handle();
       }
-      SHIM_SET_RETURN_32(X_STATUS_SUCCESS);
+      return X_STATUS_SUCCESS;
     } else {
-      SHIM_SET_RETURN_32(X_STATUS_INVALID_HANDLE);
+      return X_STATUS_INVALID_HANDLE;
     }
-    return;
   }
 
-  auto timer = object_ref<XTimer>(new XTimer(kernel_state));
+  auto timer = object_ref<XTimer>(new XTimer(kernel_state()));
   timer->Initialize(timer_type);
 
   // obj_attributes may have a name inside of it, if != NULL.
@@ -766,70 +683,61 @@ SHIM_CALL NtCreateTimer_shim(PPCContext* ppc_context,
   }
 
   if (handle_ptr) {
-    SHIM_SET_MEM_32(handle_ptr, timer->handle());
+    *handle_ptr = timer->handle();
   }
 
-  SHIM_SET_RETURN_32(X_STATUS_SUCCESS);
+  return X_STATUS_SUCCESS;
 }
+DECLARE_XBOXKRNL_EXPORT1(NtCreateTimer, kThreading, kImplemented);
 
-SHIM_CALL NtSetTimerEx_shim(PPCContext* ppc_context,
-                            KernelState* kernel_state) {
-  uint32_t timer_handle = SHIM_GET_ARG_32(0);
-  uint32_t due_time_ptr = SHIM_GET_ARG_32(1);
-  uint32_t routine = SHIM_GET_ARG_32(2);  // PTIMERAPCROUTINE
-  uint32_t unk_one = SHIM_GET_ARG_32(3);
-  uint32_t routine_arg = SHIM_GET_ARG_32(4);
-  uint32_t resume = SHIM_GET_ARG_32(5);
-  uint32_t period_ms = SHIM_GET_ARG_32(6);
-  uint32_t unk_zero = SHIM_GET_ARG_32(7);
-
+dword_result_t NtSetTimerEx(dword_t timer_handle, lpqword_t due_time_ptr,
+                            lpvoid_t routine_ptr /*PTIMERAPCROUTINE*/,
+                            dword_t unk_one, lpvoid_t routine_arg,
+                            dword_t resume, dword_t period_ms,
+                            dword_t unk_zero) {
   assert_true(unk_one == 1);
   assert_true(unk_zero == 0);
 
-  uint64_t due_time = SHIM_MEM_64(due_time_ptr);
-
-  XELOGD("NtSetTimerEx(%.8X, %.8X(%lld), %.8X, %.8X, %.8X, %.1X, %d, %.8X)",
-         timer_handle, due_time_ptr, due_time, routine, unk_one, routine_arg,
-         resume, period_ms, unk_zero);
+  uint64_t due_time = *due_time_ptr;
 
   X_STATUS result = X_STATUS_SUCCESS;
 
-  auto timer = kernel_state->object_table()->LookupObject<XTimer>(timer_handle);
+  auto timer =
+      kernel_state()->object_table()->LookupObject<XTimer>(timer_handle);
   if (timer) {
-    result = timer->SetTimer(due_time, period_ms, routine, routine_arg,
-                             resume ? true : false);
+    result =
+        timer->SetTimer(due_time, period_ms, routine_ptr.guest_address(),
+                        routine_arg.guest_address(), resume ? true : false);
   } else {
     result = X_STATUS_INVALID_HANDLE;
   }
 
-  SHIM_SET_RETURN_32(result);
+  return result;
 }
+DECLARE_XBOXKRNL_EXPORT1(NtSetTimerEx, kThreading, kImplemented);
 
-SHIM_CALL NtCancelTimer_shim(PPCContext* ppc_context,
-                             KernelState* kernel_state) {
-  uint32_t timer_handle = SHIM_GET_ARG_32(0);
-  uint32_t current_state_ptr = SHIM_GET_ARG_32(1);
-
-  XELOGD("NtCancelTimer(%.8X, %.8X)", timer_handle, current_state_ptr);
-
+dword_result_t NtCancelTimer(dword_t timer_handle,
+                             lpdword_t current_state_ptr) {
   X_STATUS result = X_STATUS_SUCCESS;
 
-  auto timer = kernel_state->object_table()->LookupObject<XTimer>(timer_handle);
+  auto timer =
+      kernel_state()->object_table()->LookupObject<XTimer>(timer_handle);
   if (timer) {
     result = timer->Cancel();
   } else {
     result = X_STATUS_INVALID_HANDLE;
   }
   if (current_state_ptr) {
-    SHIM_SET_MEM_32(current_state_ptr, 0);
+    *current_state_ptr = 0;
   }
 
-  SHIM_SET_RETURN_32(result);
+  return result;
 }
+DECLARE_XBOXKRNL_EXPORT1(NtCancelTimer, kThreading, kImplemented);
 
-dword_result_t KeWaitForSingleObject(lpvoid_t object_ptr, dword_t wait_reason,
-                                     dword_t processor_mode, dword_t alertable,
-                                     lpqword_t timeout_ptr) {
+uint32_t xeKeWaitForSingleObject(void* object_ptr, uint32_t wait_reason,
+                                 uint32_t processor_mode, uint32_t alertable,
+                                 uint64_t* timeout_ptr) {
   auto object = XObject::GetNativeObject<XObject>(kernel_state(), object_ptr);
 
   if (!object) {
@@ -838,15 +746,21 @@ dword_result_t KeWaitForSingleObject(lpvoid_t object_ptr, dword_t wait_reason,
     return X_STATUS_ABANDONED_WAIT_0;
   }
 
-  uint64_t timeout = timeout_ptr ? static_cast<uint64_t>(*timeout_ptr) : 0u;
-  X_STATUS result = object->Wait(wait_reason, processor_mode, alertable,
-                                 timeout_ptr ? &timeout : nullptr);
+  X_STATUS result =
+      object->Wait(wait_reason, processor_mode, alertable, timeout_ptr);
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(KeWaitForSingleObject,
-                        ExportTag::kImplemented | ExportTag::kThreading |
-                            ExportTag::kBlocking | ExportTag::kHighFrequency);
+
+dword_result_t KeWaitForSingleObject(lpvoid_t object_ptr, dword_t wait_reason,
+                                     dword_t processor_mode, dword_t alertable,
+                                     lpqword_t timeout_ptr) {
+  uint64_t timeout = timeout_ptr ? static_cast<uint64_t>(*timeout_ptr) : 0u;
+  return xeKeWaitForSingleObject(object_ptr, wait_reason, processor_mode,
+                                 alertable, timeout_ptr ? &timeout : nullptr);
+}
+DECLARE_XBOXKRNL_EXPORT3(KeWaitForSingleObject, kThreading, kImplemented,
+                         kBlocking, kHighFrequency);
 
 dword_result_t NtWaitForSingleObjectEx(dword_t object_handle, dword_t wait_mode,
                                        dword_t alertable,
@@ -865,9 +779,8 @@ dword_result_t NtWaitForSingleObjectEx(dword_t object_handle, dword_t wait_mode,
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(NtWaitForSingleObjectEx,
-                        ExportTag::kImplemented | ExportTag::kThreading |
-                            ExportTag::kBlocking | ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT3(NtWaitForSingleObjectEx, kThreading, kImplemented,
+                         kBlocking, kHighFrequency);
 
 dword_result_t KeWaitForMultipleObjects(dword_t count, lpdword_t objects_ptr,
                                         dword_t wait_type, dword_t wait_reason,
@@ -877,8 +790,6 @@ dword_result_t KeWaitForMultipleObjects(dword_t count, lpdword_t objects_ptr,
                                         lpvoid_t wait_block_array_ptr) {
   assert_true(wait_type <= 1);
 
-  X_STATUS result = X_STATUS_SUCCESS;
-
   std::vector<object_ref<XObject>> objects;
   for (uint32_t n = 0; n < count; n++) {
     auto object_ptr = kernel_memory()->TranslateVirtual(objects_ptr[n]);
@@ -892,23 +803,19 @@ dword_result_t KeWaitForMultipleObjects(dword_t count, lpdword_t objects_ptr,
   }
 
   uint64_t timeout = timeout_ptr ? static_cast<uint64_t>(*timeout_ptr) : 0u;
-  result = XObject::WaitMultiple(uint32_t(objects.size()),
-                                 reinterpret_cast<XObject**>(objects.data()),
-                                 wait_type, wait_reason, processor_mode,
-                                 alertable, timeout_ptr ? &timeout : nullptr);
-
-  return result;
+  return XObject::WaitMultiple(uint32_t(objects.size()),
+                               reinterpret_cast<XObject**>(objects.data()),
+                               wait_type, wait_reason, processor_mode,
+                               alertable, timeout_ptr ? &timeout : nullptr);
 }
-DECLARE_XBOXKRNL_EXPORT(KeWaitForMultipleObjects,
-                        ExportTag::kImplemented | ExportTag::kThreading |
-                            ExportTag::kBlocking | ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT3(KeWaitForMultipleObjects, kThreading, kImplemented,
+                         kBlocking, kHighFrequency);
 
-dword_result_t NtWaitForMultipleObjectsEx(dword_t count, lpdword_t handles,
-                                          dword_t wait_type, dword_t wait_mode,
-                                          dword_t alertable,
-                                          lpqword_t timeout_ptr) {
+uint32_t xeNtWaitForMultipleObjectsEx(uint32_t count, xe::be<uint32_t>* handles,
+                                      uint32_t wait_type, uint32_t wait_mode,
+                                      uint32_t alertable,
+                                      uint64_t* timeout_ptr) {
   assert_true(wait_type <= 1);
-  X_STATUS result = X_STATUS_SUCCESS;
 
   std::vector<object_ref<XObject>> objects;
   for (uint32_t n = 0; n < count; n++) {
@@ -921,16 +828,22 @@ dword_result_t NtWaitForMultipleObjectsEx(dword_t count, lpdword_t handles,
     objects.push_back(std::move(object));
   }
 
-  uint64_t timeout = timeout_ptr ? static_cast<uint64_t>(*timeout_ptr) : 0u;
-  result = XObject::WaitMultiple(
-      count, reinterpret_cast<XObject**>(objects.data()), wait_type, 6,
-      wait_mode, alertable, timeout_ptr ? &timeout : nullptr);
-
-  return result;
+  return XObject::WaitMultiple(count,
+                               reinterpret_cast<XObject**>(objects.data()),
+                               wait_type, 6, wait_mode, alertable, timeout_ptr);
 }
-DECLARE_XBOXKRNL_EXPORT(NtWaitForMultipleObjectsEx,
-                        ExportTag::kImplemented | ExportTag::kThreading |
-                            ExportTag::kBlocking | ExportTag::kHighFrequency);
+
+dword_result_t NtWaitForMultipleObjectsEx(dword_t count, lpdword_t handles,
+                                          dword_t wait_type, dword_t wait_mode,
+                                          dword_t alertable,
+                                          lpqword_t timeout_ptr) {
+  uint64_t timeout = timeout_ptr ? static_cast<uint64_t>(*timeout_ptr) : 0u;
+  return xeNtWaitForMultipleObjectsEx(count, handles, wait_type, wait_mode,
+                                      alertable,
+                                      timeout_ptr ? &timeout : nullptr);
+}
+DECLARE_XBOXKRNL_EXPORT3(NtWaitForMultipleObjectsEx, kThreading, kImplemented,
+                         kBlocking, kHighFrequency);
 
 dword_result_t NtSignalAndWaitForSingleObjectEx(dword_t signal_handle,
                                                 dword_t wait_handle,
@@ -953,17 +866,15 @@ dword_result_t NtSignalAndWaitForSingleObjectEx(dword_t signal_handle,
 
   return result;
 }
-DECLARE_XBOXKRNL_EXPORT(NtSignalAndWaitForSingleObjectEx,
-                        ExportTag::kImplemented | ExportTag::kThreading |
-                            ExportTag::kBlocking | ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT3(NtSignalAndWaitForSingleObjectEx, kThreading,
+                         kImplemented, kBlocking, kHighFrequency);
 
-dword_result_t KfAcquireSpinLock(lpdword_t lock_ptr) {
+uint32_t xeKeKfAcquireSpinLock(uint32_t* lock) {
   // XELOGD(
   //     "KfAcquireSpinLock(%.8X)",
   //     lock_ptr);
 
   // Lock.
-  auto lock = reinterpret_cast<uint32_t*>(lock_ptr.host_address());
   while (!xe::atomic_cas(0, 1, lock)) {
     // Spin!
     // TODO(benvanik): error on deadlock?
@@ -976,22 +887,29 @@ dword_result_t KfAcquireSpinLock(lpdword_t lock_ptr) {
 
   return old_irql;
 }
-DECLARE_XBOXKRNL_EXPORT(KfAcquireSpinLock,
-                        ExportTag::kImplemented | ExportTag::kThreading |
-                            ExportTag::kHighFrequency | ExportTag::kBlocking);
 
-void KfReleaseSpinLock(lpdword_t lock_ptr, dword_t old_irql) {
+dword_result_t KfAcquireSpinLock(lpdword_t lock_ptr) {
+  auto lock = reinterpret_cast<uint32_t*>(lock_ptr.host_address());
+  return xeKeKfAcquireSpinLock(lock);
+}
+DECLARE_XBOXKRNL_EXPORT3(KfAcquireSpinLock, kThreading, kImplemented, kBlocking,
+                         kHighFrequency);
+
+void xeKeKfReleaseSpinLock(uint32_t* lock, dword_t old_irql) {
   // Restore IRQL.
   XThread* thread = XThread::GetCurrentThread();
   thread->LowerIrql(old_irql);
 
   // Unlock.
-  auto lock = reinterpret_cast<uint32_t*>(lock_ptr.host_address());
   xe::atomic_dec(lock);
 }
-DECLARE_XBOXKRNL_EXPORT(KfReleaseSpinLock, ExportTag::kImplemented |
-                                               ExportTag::kThreading |
-                                               ExportTag::kHighFrequency);
+
+void KfReleaseSpinLock(lpdword_t lock_ptr, dword_t old_irql) {
+  auto lock = reinterpret_cast<uint32_t*>(lock_ptr.host_address());
+  xeKeKfReleaseSpinLock(lock, old_irql);
+}
+DECLARE_XBOXKRNL_EXPORT2(KfReleaseSpinLock, kThreading, kImplemented,
+                         kHighFrequency);
 
 void KeAcquireSpinLockAtRaisedIrql(lpdword_t lock_ptr) {
   // Lock.
@@ -1001,109 +919,74 @@ void KeAcquireSpinLockAtRaisedIrql(lpdword_t lock_ptr) {
     // TODO(benvanik): error on deadlock?
   }
 }
-DECLARE_XBOXKRNL_EXPORT(KeAcquireSpinLockAtRaisedIrql,
-                        ExportTag::kImplemented | ExportTag::kThreading |
-                            ExportTag::kHighFrequency | ExportTag::kBlocking);
+DECLARE_XBOXKRNL_EXPORT3(KeAcquireSpinLockAtRaisedIrql, kThreading,
+                         kImplemented, kBlocking, kHighFrequency);
 
 void KeReleaseSpinLockFromRaisedIrql(lpdword_t lock_ptr) {
   // Unlock.
   auto lock = reinterpret_cast<uint32_t*>(lock_ptr.host_address());
   xe::atomic_dec(lock);
 }
-DECLARE_XBOXKRNL_EXPORT(KeReleaseSpinLockFromRaisedIrql,
-                        ExportTag::kImplemented | ExportTag::kThreading |
-                            ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(KeReleaseSpinLockFromRaisedIrql, kThreading,
+                         kImplemented, kHighFrequency);
 
-SHIM_CALL KeEnterCriticalRegion_shim(PPCContext* ppc_context,
-                                     KernelState* kernel_state) {
-  // XELOGD(
-  //     "KeEnterCriticalRegion()");
-  XThread::EnterCriticalRegion();
-}
+void KeEnterCriticalRegion() { XThread::EnterCriticalRegion(); }
+DECLARE_XBOXKRNL_EXPORT2(KeEnterCriticalRegion, kThreading, kImplemented,
+                         kHighFrequency);
 
-SHIM_CALL KeLeaveCriticalRegion_shim(PPCContext* ppc_context,
-                                     KernelState* kernel_state) {
-  // XELOGD(
-  //     "KeLeaveCriticalRegion()");
+void KeLeaveCriticalRegion() {
   XThread::LeaveCriticalRegion();
 
   XThread::GetCurrentThread()->CheckApcs();
 }
+DECLARE_XBOXKRNL_EXPORT2(KeLeaveCriticalRegion, kThreading, kImplemented,
+                         kHighFrequency);
 
-SHIM_CALL KeRaiseIrqlToDpcLevel_shim(PPCContext* ppc_context,
-                                     KernelState* kernel_state) {
-  // XELOGD(
-  //     "KeRaiseIrqlToDpcLevel()");
-  auto old_value = kernel_state->processor()->RaiseIrql(cpu::Irql::DPC);
-  SHIM_SET_RETURN_32(old_value);
+dword_result_t KeRaiseIrqlToDpcLevel() {
+  auto old_value = kernel_state()->processor()->RaiseIrql(cpu::Irql::DPC);
+  return (uint32_t)old_value;
 }
+DECLARE_XBOXKRNL_EXPORT2(KeRaiseIrqlToDpcLevel, kThreading, kImplemented,
+                         kHighFrequency);
 
-SHIM_CALL KfLowerIrql_shim(PPCContext* ppc_context, KernelState* kernel_state) {
-  uint32_t old_value = SHIM_GET_ARG_32(0);
-  // XELOGD(
-  //     "KfLowerIrql(%d)",
-  //     old_value);
-  kernel_state->processor()->LowerIrql(static_cast<cpu::Irql>(old_value));
+void KfLowerIrql(dword_t old_value) {
+  kernel_state()->processor()->LowerIrql(
+      static_cast<cpu::Irql>((uint32_t)old_value));
 
   XThread::GetCurrentThread()->CheckApcs();
 }
+DECLARE_XBOXKRNL_EXPORT2(KfLowerIrql, kThreading, kImplemented, kHighFrequency);
 
-SHIM_CALL NtQueueApcThread_shim(PPCContext* ppc_context,
-                                KernelState* kernel_state) {
-  uint32_t thread_handle = SHIM_GET_ARG_32(0);
-  uint32_t apc_routine = SHIM_GET_ARG_32(1);
-  uint32_t arg1 = SHIM_GET_ARG_32(2);
-  uint32_t arg2 = SHIM_GET_ARG_32(3);
-  uint32_t arg3 = SHIM_GET_ARG_32(4);  // ?
-  XELOGD("NtQueueApcThread(%.8X, %.8X, %.8X, %.8X, %.8X)", thread_handle,
-         apc_routine, arg1, arg2, arg3);
-
+void NtQueueApcThread(dword_t thread_handle, lpvoid_t apc_routine,
+                      lpvoid_t arg1, lpvoid_t arg2, lpvoid_t arg3) {
   // Alloc APC object (from somewhere) and insert.
 
   assert_always("not implemented");
 }
+// DECLARE_XBOXKRNL_EXPORT1(NtQueueApcThread, kThreading, kStub);
 
-SHIM_CALL KeInitializeApc_shim(PPCContext* ppc_context,
-                               KernelState* kernel_state) {
-  uint32_t apc_ptr = SHIM_GET_ARG_32(0);
-  uint32_t thread = SHIM_GET_ARG_32(1);
-  uint32_t kernel_routine = SHIM_GET_ARG_32(2);
-  uint32_t rundown_routine = SHIM_GET_ARG_32(3);
-  uint32_t normal_routine = SHIM_GET_ARG_32(4);
-  uint32_t processor_mode = SHIM_GET_ARG_32(5);
-  uint32_t normal_context = SHIM_GET_ARG_32(6);
-
-  XELOGD("KeInitializeApc(%.8X, %.8X, %.8X, %.8X, %.8X, %.8X, %.8X)", apc_ptr,
-         thread, kernel_routine, rundown_routine, normal_routine,
-         processor_mode, normal_context);
-
-  auto apc = SHIM_STRUCT(XAPC, apc_ptr);
+void KeInitializeApc(pointer_t<XAPC> apc, lpvoid_t thread_ptr,
+                     lpvoid_t kernel_routine, lpvoid_t rundown_routine,
+                     lpvoid_t normal_routine, dword_t processor_mode,
+                     lpvoid_t normal_context) {
   apc->Initialize();
   apc->processor_mode = processor_mode;
-  apc->thread_ptr = thread;
-  apc->kernel_routine = kernel_routine;
-  apc->rundown_routine = rundown_routine;
-  apc->normal_routine = normal_routine;
-  apc->normal_context = normal_routine ? normal_context : 0;
+  apc->thread_ptr = thread_ptr.guest_address();
+  apc->kernel_routine = kernel_routine.guest_address();
+  apc->rundown_routine = rundown_routine.guest_address();
+  apc->normal_routine = normal_routine.guest_address();
+  apc->normal_context =
+      normal_routine.guest_address() ? normal_context.guest_address() : 0;
 }
+DECLARE_XBOXKRNL_EXPORT1(KeInitializeApc, kThreading, kImplemented);
 
-SHIM_CALL KeInsertQueueApc_shim(PPCContext* ppc_context,
-                                KernelState* kernel_state) {
-  uint32_t apc_ptr = SHIM_GET_ARG_32(0);
-  uint32_t arg1 = SHIM_GET_ARG_32(1);
-  uint32_t arg2 = SHIM_GET_ARG_32(2);
-  uint32_t priority_increment = SHIM_GET_ARG_32(3);
-
-  XELOGD("KeInsertQueueApc(%.8X, %.8X, %.8X, %.8X)", apc_ptr, arg1, arg2,
-         priority_increment);
-
-  auto apc = SHIM_STRUCT(XAPC, apc_ptr);
-
+dword_result_t KeInsertQueueApc(pointer_t<XAPC> apc, lpvoid_t arg1,
+                                lpvoid_t arg2, dword_t priority_increment) {
   auto thread = XObject::GetNativeObject<XThread>(
-      kernel_state, SHIM_MEM_ADDR(apc->thread_ptr));
+      kernel_state(),
+      kernel_state()->memory()->TranslateVirtual(apc->thread_ptr));
   if (!thread) {
-    SHIM_SET_RETURN_32(0);
-    return;
+    return 0;
   }
 
   // Lock thread.
@@ -1112,53 +995,45 @@ SHIM_CALL KeInsertQueueApc_shim(PPCContext* ppc_context,
   // Fail if already inserted.
   if (apc->enqueued) {
     thread->UnlockApc(false);
-    SHIM_SET_RETURN_32(0);
-    return;
+    return 0;
   }
 
   // Prep APC.
-  apc->arg1 = arg1;
-  apc->arg2 = arg2;
+  apc->arg1 = arg1.guest_address();
+  apc->arg2 = arg2.guest_address();
   apc->enqueued = 1;
 
   auto apc_list = thread->apc_list();
 
-  uint32_t list_entry_ptr = apc_ptr + 8;
+  uint32_t list_entry_ptr = apc.guest_address() + 8;
   apc_list->Insert(list_entry_ptr);
 
   // Unlock thread.
   thread->UnlockApc(true);
 
-  SHIM_SET_RETURN_32(1);
+  return 1;
 }
+DECLARE_XBOXKRNL_EXPORT1(KeInsertQueueApc, kThreading, kImplemented);
 
-SHIM_CALL KeRemoveQueueApc_shim(PPCContext* ppc_context,
-                                KernelState* kernel_state) {
-  uint32_t apc_ptr = SHIM_GET_ARG_32(0);
-
-  XELOGD("KeRemoveQueueApc(%.8X)", apc_ptr);
-
+dword_result_t KeRemoveQueueApc(pointer_t<XAPC> apc) {
   bool result = false;
 
-  auto apc = SHIM_STRUCT(XAPC, apc_ptr);
-
   auto thread = XObject::GetNativeObject<XThread>(
-      kernel_state, SHIM_MEM_ADDR(apc->thread_ptr));
+      kernel_state(),
+      kernel_state()->memory()->TranslateVirtual(apc->thread_ptr));
   if (!thread) {
-    SHIM_SET_RETURN_32(0);
-    return;
+    return 0;
   }
 
   thread->LockApc();
 
   if (!apc->enqueued) {
     thread->UnlockApc(false);
-    SHIM_SET_RETURN_32(0);
-    return;
+    return 0;
   }
 
   auto apc_list = thread->apc_list();
-  uint32_t list_entry_ptr = apc_ptr + 8;
+  uint32_t list_entry_ptr = apc.guest_address() + 8;
   if (apc_list->IsQueued(list_entry_ptr)) {
     apc_list->Remove(list_entry_ptr);
     result = true;
@@ -1166,90 +1041,81 @@ SHIM_CALL KeRemoveQueueApc_shim(PPCContext* ppc_context,
 
   thread->UnlockApc(true);
 
-  SHIM_SET_RETURN_32(result ? 1 : 0);
+  return result ? 1 : 0;
 }
+DECLARE_XBOXKRNL_EXPORT1(KeRemoveQueueApc, kThreading, kImplemented);
 
-SHIM_CALL KiApcNormalRoutineNop_shim(PPCContext* ppc_context,
-                                     KernelState* kernel_state) {
-  uint32_t unk0 = SHIM_GET_ARG_32(0);  // output?
-  uint32_t unk1 = SHIM_GET_ARG_32(1);  // 0x13
-
-  XELOGD("KiApcNormalRoutineNop(%.8X, %.8X)", unk0, unk1);
-
-  SHIM_SET_RETURN_32(0);
+dword_result_t KiApcNormalRoutineNop(dword_t unk0 /* output? */,
+                                     dword_t unk1 /* 0x13 */) {
+  return 0;
 }
+DECLARE_XBOXKRNL_EXPORT1(KiApcNormalRoutineNop, kThreading, kStub);
 
-SHIM_CALL KeInitializeDpc_shim(PPCContext* ppc_context,
-                               KernelState* kernel_state) {
-  uint32_t dpc_ptr = SHIM_GET_ARG_32(0);
-  uint32_t routine = SHIM_GET_ARG_32(1);
-  uint32_t context = SHIM_GET_ARG_32(2);
-
-  XELOGD("KeInitializeDpc(%.8X, %.8X, %.8X)", dpc_ptr, routine, context);
+typedef struct {
+  xe::be<uint32_t> unknown;
+  xe::be<uint32_t> flink;
+  xe::be<uint32_t> blink;
+  xe::be<uint32_t> routine;
+  xe::be<uint32_t> context;
+  xe::be<uint32_t> arg1;
+  xe::be<uint32_t> arg2;
+} XDPC;
 
+void KeInitializeDpc(pointer_t<XDPC> dpc, lpvoid_t routine, lpvoid_t context) {
   // KDPC (maybe) 0x18 bytes?
   uint32_t type = 19;  // DpcObject
   uint32_t importance = 0;
   uint32_t number = 0;  // ?
-  SHIM_SET_MEM_32(dpc_ptr + 0, (type << 24) | (importance << 16) | (number));
-  SHIM_SET_MEM_32(dpc_ptr + 4, 0);  // flink
-  SHIM_SET_MEM_32(dpc_ptr + 8, 0);  // blink
-  SHIM_SET_MEM_32(dpc_ptr + 12, routine);
-  SHIM_SET_MEM_32(dpc_ptr + 16, context);
-  SHIM_SET_MEM_32(dpc_ptr + 20, 0);  // arg1
-  SHIM_SET_MEM_32(dpc_ptr + 24, 0);  // arg2
+  dpc->unknown = (type << 24) | (importance << 16) | (number);
+  dpc->flink = 0;
+  dpc->blink = 0;
+  dpc->routine = routine.guest_address();
+  dpc->context = context.guest_address();
+  dpc->arg1 = 0;
+  dpc->arg2 = 0;
 }
+DECLARE_XBOXKRNL_EXPORT2(KeInitializeDpc, kThreading, kImplemented, kSketchy);
 
-SHIM_CALL KeInsertQueueDpc_shim(PPCContext* ppc_context,
-                                KernelState* kernel_state) {
-  uint32_t dpc_ptr = SHIM_GET_ARG_32(0);
-  uint32_t arg1 = SHIM_GET_ARG_32(1);
-  uint32_t arg2 = SHIM_GET_ARG_32(2);
-
+dword_result_t KeInsertQueueDpc(pointer_t<XDPC> dpc, dword_t arg1,
+                                dword_t arg2) {
   assert_always("DPC does not dispatch yet; going to hang!");
 
-  XELOGD("KeInsertQueueDpc(%.8X, %.8X, %.8X)", dpc_ptr, arg1, arg2);
-
-  uint32_t list_entry_ptr = dpc_ptr + 4;
+  uint32_t list_entry_ptr = dpc.guest_address() + 4;
 
   // Lock dispatcher.
   auto global_lock = xe::global_critical_region::AcquireDirect();
-  auto dpc_list = kernel_state->dpc_list();
+  auto dpc_list = kernel_state()->dpc_list();
 
   // If already in a queue, abort.
   if (dpc_list->IsQueued(list_entry_ptr)) {
-    SHIM_SET_RETURN_32(0);
-    return;
+    return 0;
   }
 
   // Prep DPC.
-  SHIM_SET_MEM_32(dpc_ptr + 20, arg1);
-  SHIM_SET_MEM_32(dpc_ptr + 24, arg2);
+  dpc->arg1 = (uint32_t)arg1;
+  dpc->arg2 = (uint32_t)arg2;
 
   dpc_list->Insert(list_entry_ptr);
 
-  SHIM_SET_RETURN_32(1);
+  return 1;
 }
+DECLARE_XBOXKRNL_EXPORT2(KeInsertQueueDpc, kThreading, kStub, kSketchy);
 
-SHIM_CALL KeRemoveQueueDpc_shim(PPCContext* ppc_context,
-                                KernelState* kernel_state) {
-  uint32_t dpc_ptr = SHIM_GET_ARG_32(0);
-
-  XELOGD("KeRemoveQueueDpc(%.8X)", dpc_ptr);
-
+dword_result_t KeRemoveQueueDpc(pointer_t<XDPC> dpc) {
   bool result = false;
 
-  uint32_t list_entry_ptr = dpc_ptr + 4;
+  uint32_t list_entry_ptr = dpc.guest_address() + 4;
 
   auto global_lock = xe::global_critical_region::AcquireDirect();
-  auto dpc_list = kernel_state->dpc_list();
+  auto dpc_list = kernel_state()->dpc_list();
   if (dpc_list->IsQueued(list_entry_ptr)) {
     dpc_list->Remove(list_entry_ptr);
     result = true;
   }
 
-  SHIM_SET_RETURN_32(result ? 1 : 0);
+  return result ? 1 : 0;
 }
+DECLARE_XBOXKRNL_EXPORT1(KeRemoveQueueDpc, kThreading, kImplemented);
 
 // https://github.com/Cxbx-Reloaded/Cxbx-Reloaded/blob/51e4dfcaacfdbd1a9692272931a436371492f72d/import/OpenXDK/include/xboxkrnl/xboxkrnl.h#L1372
 struct X_ERWLOCK {
@@ -1259,8 +1125,9 @@ struct X_ERWLOCK {
   be<uint32_t> readers_entry_count;    // 0xC
   X_KEVENT writer_event;               // 0x10
   X_KSEMAPHORE reader_semaphore;       // 0x20
-  be<uint32_t> spin_lock;              // 0x34
+  uint32_t spin_lock;                  // 0x34
 };
+static_assert_size(X_ERWLOCK, 0x38);
 
 void ExInitializeReadWriteLock(pointer_t<X_ERWLOCK> lock_ptr) {
   lock_ptr->lock_count = -1;
@@ -1269,9 +1136,54 @@ void ExInitializeReadWriteLock(pointer_t<X_ERWLOCK> lock_ptr) {
   lock_ptr->readers_entry_count = 0;
   KeInitializeEvent(&lock_ptr->writer_event, 1, 0);
   KeInitializeSemaphore(&lock_ptr->reader_semaphore, 0, 0x7FFFFFFF);
+  lock_ptr->spin_lock = 0;
 }
-DECLARE_XBOXKRNL_EXPORT(ExInitializeReadWriteLock,
-                        ExportTag::kThreading | ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(ExInitializeReadWriteLock, kThreading, kImplemented);
+
+void ExAcquireReadWriteLockExclusive(pointer_t<X_ERWLOCK> lock_ptr) {
+  auto old_irql = xeKeKfAcquireSpinLock(&lock_ptr->spin_lock);
+  lock_ptr->lock_count++;
+  xeKeKfReleaseSpinLock(&lock_ptr->spin_lock, old_irql);
+
+  if (!lock_ptr->lock_count) {
+    return;
+  }
+
+  lock_ptr->writers_waiting_count++;
+  xeKeWaitForSingleObject(&lock_ptr->writer_event, 0, 0, 0, nullptr);
+}
+DECLARE_XBOXKRNL_EXPORT3(ExAcquireReadWriteLockExclusive, kThreading,
+                         kImplemented, kBlocking, kSketchy);
+
+void ExReleaseReadWriteLock(pointer_t<X_ERWLOCK> lock_ptr) {
+  auto old_irql = xeKeKfAcquireSpinLock(&lock_ptr->spin_lock);
+  lock_ptr->lock_count--;
+
+  if (lock_ptr->lock_count < 0) {
+    xeKeKfReleaseSpinLock(&lock_ptr->spin_lock, old_irql);
+    return;
+  }
+
+  if (!lock_ptr->readers_entry_count) {
+    auto readers_waiting_count = lock_ptr->readers_waiting_count;
+    if (readers_waiting_count) {
+      lock_ptr->readers_waiting_count = 0;
+      lock_ptr->readers_entry_count = readers_waiting_count;
+      xeKeKfReleaseSpinLock(&lock_ptr->spin_lock, old_irql);
+      xeKeReleaseSemaphore(&lock_ptr->reader_semaphore, 1,
+                           readers_waiting_count, 0);
+      return;
+    }
+  }
+
+  auto count = lock_ptr->readers_entry_count--;
+  xeKeKfReleaseSpinLock(&lock_ptr->spin_lock, old_irql);
+  if (!count) {
+    xeKeSetEvent(&lock_ptr->writer_event, 1, 0);
+  }
+}
+DECLARE_XBOXKRNL_EXPORT2(ExReleaseReadWriteLock, kThreading, kImplemented,
+                         kSketchy);
 
 // NOTE: This function is very commonly inlined, and probably won't be called!
 pointer_result_t InterlockedPushEntrySList(
@@ -1296,8 +1208,8 @@ pointer_result_t InterlockedPushEntrySList(
 
   return old_head;
 }
-DECLARE_XBOXKRNL_EXPORT(InterlockedPushEntrySList,
-                        ExportTag::kImplemented | ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(InterlockedPushEntrySList, kThreading, kImplemented,
+                         kHighFrequency);
 
 pointer_result_t InterlockedPopEntrySList(pointer_t<X_SLIST_HEADER> plist_ptr) {
   assert_not_null(plist_ptr);
@@ -1323,8 +1235,8 @@ pointer_result_t InterlockedPopEntrySList(pointer_t<X_SLIST_HEADER> plist_ptr) {
 
   return popped;
 }
-DECLARE_XBOXKRNL_EXPORT(InterlockedPopEntrySList,
-                        ExportTag::kImplemented | ExportTag::kHighFrequency);
+DECLARE_XBOXKRNL_EXPORT2(InterlockedPopEntrySList, kThreading, kImplemented,
+                         kHighFrequency);
 
 pointer_result_t InterlockedFlushSList(pointer_t<X_SLIST_HEADER> plist_ptr) {
   assert_not_null(plist_ptr);
@@ -1344,52 +1256,10 @@ pointer_result_t InterlockedFlushSList(pointer_t<X_SLIST_HEADER> plist_ptr) {
 
   return first;
 }
-DECLARE_XBOXKRNL_EXPORT(InterlockedFlushSList, ExportTag::kImplemented);
+DECLARE_XBOXKRNL_EXPORT1(InterlockedFlushSList, kThreading, kImplemented);
 
 void RegisterThreadingExports(xe::cpu::ExportResolver* export_resolver,
-                              KernelState* kernel_state) {
-  SHIM_SET_MAPPING("xboxkrnl.exe", ExCreateThread, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", ExTerminateThread, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", NtResumeThread, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeResumeThread, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", NtSuspendThread, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeSetAffinityThread, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeQueryBasePriorityThread, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeSetBasePriorityThread, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeSetDisableBoostThread, state);
-
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeGetCurrentProcessType, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeSetCurrentProcessType, state);
-
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeQueryPerformanceFrequency, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", NtYieldExecution, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeQuerySystemTime, state);
-
-  SHIM_SET_MAPPING("xboxkrnl.exe", NtCreateSemaphore, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", NtReleaseSemaphore, state);
-
-  SHIM_SET_MAPPING("xboxkrnl.exe", NtReleaseMutant, state);
-
-  SHIM_SET_MAPPING("xboxkrnl.exe", NtCreateTimer, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", NtSetTimerEx, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", NtCancelTimer, state);
-
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeEnterCriticalRegion, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeLeaveCriticalRegion, state);
-
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeRaiseIrqlToDpcLevel, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KfLowerIrql, state);
-
-  // SHIM_SET_MAPPING("xboxkrnl.exe", NtQueueApcThread, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeInitializeApc, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeInsertQueueApc, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeRemoveQueueApc, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KiApcNormalRoutineNop, state);
-
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeInitializeDpc, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeInsertQueueDpc, state);
-  SHIM_SET_MAPPING("xboxkrnl.exe", KeRemoveQueueDpc, state);
-}
+                              KernelState* kernel_state) {}
 
 }  // namespace xboxkrnl
 }  // namespace kernel
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_threading.h b/src/xenia/kernel/xboxkrnl/xboxkrnl_threading.h
index f69f767e2..d405d4ce2 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_threading.h
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_threading.h
@@ -19,19 +19,18 @@ struct X_KEVENT;
 
 namespace xboxkrnl {
 
-dword_result_t NtSetEvent(dword_t handle, lpdword_t previous_state_ptr);
-dword_result_t NtClearEvent(dword_t handle);
+uint32_t xeNtSetEvent(uint32_t handle, xe::be<uint32_t>* previous_state_ptr);
+uint32_t xeNtClearEvent(uint32_t handle);
 
-dword_result_t NtWaitForMultipleObjectsEx(dword_t count, lpdword_t handles,
-                                          dword_t wait_type, dword_t wait_mode,
-                                          dword_t alertable,
-                                          lpqword_t timeout_ptr);
+uint32_t xeNtWaitForMultipleObjectsEx(uint32_t count, xe::be<uint32_t>* handles,
+                                      uint32_t wait_type, uint32_t wait_mode,
+                                      uint32_t alertable,
+                                      uint64_t* timeout_ptr);
 
-dword_result_t KeWaitForSingleObject(lpvoid_t object_ptr, dword_t wait_reason,
-                                     dword_t processor_mode, dword_t alertable,
-                                     lpqword_t timeout_ptr);
-dword_result_t KeSetEvent(pointer_t<X_KEVENT> event_ptr, dword_t increment,
-                          dword_t wait);
+uint32_t xeKeWaitForSingleObject(void* object_ptr, uint32_t wait_reason,
+                                 uint32_t processor_mode, uint32_t alertable,
+                                 uint64_t* timeout_ptr);
+uint32_t xeKeSetEvent(X_KEVENT* event_ptr, uint32_t increment, uint32_t wait);
 
 }  // namespace xboxkrnl
 }  // namespace kernel
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_usbcam.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_usbcam.cc
index 28c85abb1..8c02e50c6 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_usbcam.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_usbcam.cc
@@ -23,13 +23,13 @@ dword_result_t XUsbcamCreate(unknown_t unk1,  // E
   // 0 = success.
   return X_ERROR_DEVICE_NOT_CONNECTED;
 }
-DECLARE_XBOXKRNL_EXPORT(XUsbcamCreate, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(XUsbcamCreate, kNone, kStub);
 
 dword_result_t XUsbcamGetState() {
   // 0 = not connected.
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(XUsbcamGetState, ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(XUsbcamGetState, kNone, kStub);
 
 void RegisterUsbcamExports(xe::cpu::ExportResolver* export_resolver,
                            KernelState* kernel_state) {}
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc
index 1f5d40f5f..3074bd1ea 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc
@@ -9,6 +9,8 @@
 
 #include "xenia/kernel/xboxkrnl/xboxkrnl_video.h"
 
+#include <gflags/gflags.h>
+
 #include "xenia/base/logging.h"
 #include "xenia/emulator.h"
 #include "xenia/gpu/graphics_system.h"
@@ -20,35 +22,39 @@
 #include "xenia/kernel/xboxkrnl/xboxkrnl_rtl.h"
 #include "xenia/xbox.h"
 
+DEFINE_int32(kernel_display_gamma_type, 1,
+             "Display gamma type: 0 - linear, 1 - sRGB, 2 - TV (BT.709), "
+             "3 - power specified via kernel_display_gamma_power.");
+DEFINE_double(kernel_display_gamma_power, 2.22222233,
+              "Display gamma to use with kernel_display_gamma_type 3.");
+
 namespace xe {
 namespace kernel {
 namespace xboxkrnl {
 
-// http://www.tweakoz.com/orkid/
+// https://web.archive.org/web/20150805074003/https://www.tweakoz.com/orkid/
 // http://www.tweakoz.com/orkid/dox/d3/d52/xb360init_8cpp_source.html
 // https://github.com/Free60Project/xenosfb/
 // https://github.com/Free60Project/xenosfb/blob/master/src/xe.h
 // https://github.com/gligli/libxemit
-// http://web.archive.org/web/20090428095215/http://msdn.microsoft.com/en-us/library/bb313877.aspx
-// http://web.archive.org/web/20100423054747/http://msdn.microsoft.com/en-us/library/bb313961.aspx
-// http://web.archive.org/web/20100423054747/http://msdn.microsoft.com/en-us/library/bb313878.aspx
-// http://web.archive.org/web/20090510235238/http://msdn.microsoft.com/en-us/library/bb313942.aspx
-// http://svn.dd-wrt.com/browser/src/linux/universal/linux-3.8/drivers/gpu/drm/radeon/radeon_ring.c
-// http://www.microsoft.com/en-za/download/details.aspx?id=5313 -- "Stripped
+// https://web.archive.org/web/20090428095215/https://msdn.microsoft.com/en-us/library/bb313877.aspx
+// https://web.archive.org/web/20100423054747/https://msdn.microsoft.com/en-us/library/bb313961.aspx
+// https://web.archive.org/web/20100423054747/https://msdn.microsoft.com/en-us/library/bb313878.aspx
+// https://web.archive.org/web/20090510235238/https://msdn.microsoft.com/en-us/library/bb313942.aspx
+// https://svn.dd-wrt.com/browser/src/linux/universal/linux-3.8/drivers/gpu/drm/radeon/radeon_ring.c?rev=21595
+// https://www.microsoft.com/en-za/download/details.aspx?id=5313 -- "Stripped
 // Down Direct3D: Xbox 360 Command Buffer and Resource Management"
 
-void VdGetCurrentDisplayGamma(lpdword_t type_ptr, lpfloat_t unknown_ptr) {
-  /*
-  enum class GammaType {
-    SRGB = 1,
-    Unknown = 2,
-    Linear = 3,
-  };
-  */
-  *type_ptr = 1;
-  *unknown_ptr = 2.22222233f;  // maybe brightness?
+void VdGetCurrentDisplayGamma(lpdword_t type_ptr, lpfloat_t power_ptr) {
+  // 1 - sRGB.
+  // 2 - TV (BT.709).
+  // 3 - use the power written to *power_ptr.
+  // Anything else - linear.
+  // Used in D3D SetGammaRamp/SetPWLGamma to adjust the ramp for the display.
+  *type_ptr = uint32_t(FLAGS_kernel_display_gamma_type);
+  *power_ptr = float(FLAGS_kernel_display_gamma_power);
 }
-DECLARE_XBOXKRNL_EXPORT(VdGetCurrentDisplayGamma, ExportTag::kVideo);
+DECLARE_XBOXKRNL_EXPORT1(VdGetCurrentDisplayGamma, kVideo, kStub);
 
 struct X_D3DPRIVATE_RECT {
   xe::be<uint32_t> x1;  // 0x0
@@ -121,7 +127,7 @@ void VdGetCurrentDisplayInformation(pointer_t<X_DISPLAY_INFO> display_info) {
   display_info->display_refresh_rate = mode.refresh_rate;
   display_info->actual_display_width = (uint16_t)mode.display_width;
 }
-DECLARE_XBOXKRNL_EXPORT(VdGetCurrentDisplayInformation, ExportTag::kVideo);
+DECLARE_XBOXKRNL_EXPORT1(VdGetCurrentDisplayInformation, kVideo, kStub);
 
 void VdQueryVideoMode(pointer_t<X_VIDEO_MODE> video_mode) {
   // TODO(benvanik): get info from actual display.
@@ -136,7 +142,7 @@ void VdQueryVideoMode(pointer_t<X_VIDEO_MODE> video_mode) {
   video_mode->unknown_0x8a = 0x4A;
   video_mode->unknown_0x01 = 0x01;
 }
-DECLARE_XBOXKRNL_EXPORT(VdQueryVideoMode, ExportTag::kVideo);
+DECLARE_XBOXKRNL_EXPORT1(VdQueryVideoMode, kVideo, kStub);
 
 dword_result_t VdQueryVideoFlags() {
   X_VIDEO_MODE mode;
@@ -149,7 +155,7 @@ dword_result_t VdQueryVideoFlags() {
 
   return flags;
 }
-DECLARE_XBOXKRNL_EXPORT(VdQueryVideoFlags, ExportTag::kVideo);
+DECLARE_XBOXKRNL_EXPORT1(VdQueryVideoFlags, kVideo, kStub);
 
 dword_result_t VdSetDisplayMode(dword_t flags) {
   // Often 0x40000000.
@@ -168,7 +174,7 @@ dword_result_t VdSetDisplayMode(dword_t flags) {
 
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(VdSetDisplayMode, ExportTag::kVideo | ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(VdSetDisplayMode, kVideo, kStub);
 
 dword_result_t VdSetDisplayModeOverride(unknown_t unk0, unknown_t unk1,
                                         double_t refresh_rate, unknown_t unk3,
@@ -176,8 +182,7 @@ dword_result_t VdSetDisplayModeOverride(unknown_t unk0, unknown_t unk1,
   // refresh_rate = 0, 50, 59.9, etc.
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(VdSetDisplayModeOverride,
-                        ExportTag::kVideo | ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(VdSetDisplayModeOverride, kVideo, kStub);
 
 dword_result_t VdInitializeEngines(unknown_t unk0, function_t callback,
                                    lpvoid_t arg, lpdword_t pfp_ptr,
@@ -189,29 +194,27 @@ dword_result_t VdInitializeEngines(unknown_t unk0, function_t callback,
   // r7 = ME Microcode
   return 1;
 }
-DECLARE_XBOXKRNL_EXPORT(VdInitializeEngines,
-                        ExportTag::kVideo | ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(VdInitializeEngines, kVideo, kStub);
 
 void VdShutdownEngines() {
   // Ignored for now.
   // Games seem to call an Initialize/Shutdown pair to query info, then
   // re-initialize.
 }
-DECLARE_XBOXKRNL_EXPORT(VdShutdownEngines,
-                        ExportTag::kVideo | ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(VdShutdownEngines, kVideo, kStub);
 
 dword_result_t VdGetGraphicsAsicID() {
   // Games compare for < 0x10 and do VdInitializeEDRAM, else other
   // (retrain/etc).
   return 0x11;
 }
-DECLARE_XBOXKRNL_EXPORT(VdGetGraphicsAsicID, ExportTag::kVideo);
+DECLARE_XBOXKRNL_EXPORT1(VdGetGraphicsAsicID, kVideo, kStub);
 
 dword_result_t VdEnableDisableClockGating(dword_t enabled) {
   // Ignored, as it really doesn't matter.
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(VdEnableDisableClockGating, ExportTag::kVideo);
+DECLARE_XBOXKRNL_EXPORT1(VdEnableDisableClockGating, kVideo, kStub);
 
 void VdSetGraphicsInterruptCallback(function_t callback, lpvoid_t user_data) {
   // callback takes 2 params
@@ -220,7 +223,7 @@ void VdSetGraphicsInterruptCallback(function_t callback, lpvoid_t user_data) {
   auto graphics_system = kernel_state()->emulator()->graphics_system();
   graphics_system->SetInterruptCallback(callback, user_data);
 }
-DECLARE_XBOXKRNL_EXPORT(VdSetGraphicsInterruptCallback, ExportTag::kVideo);
+DECLARE_XBOXKRNL_EXPORT1(VdSetGraphicsInterruptCallback, kVideo, kImplemented);
 
 void VdInitializeRingBuffer(lpvoid_t ptr, int_t log2_size) {
   // r3 = result of MmGetPhysicalAddress
@@ -229,28 +232,27 @@ void VdInitializeRingBuffer(lpvoid_t ptr, int_t log2_size) {
   auto graphics_system = kernel_state()->emulator()->graphics_system();
   graphics_system->InitializeRingBuffer(ptr, log2_size);
 }
-DECLARE_XBOXKRNL_EXPORT(VdInitializeRingBuffer, ExportTag::kVideo);
+DECLARE_XBOXKRNL_EXPORT1(VdInitializeRingBuffer, kVideo, kImplemented);
 
 void VdEnableRingBufferRPtrWriteBack(lpvoid_t ptr, int_t block_size) {
   // r4 = 6, usually --- <=19
   auto graphics_system = kernel_state()->emulator()->graphics_system();
   graphics_system->EnableReadPointerWriteBack(ptr, block_size);
 }
-DECLARE_XBOXKRNL_EXPORT(VdEnableRingBufferRPtrWriteBack, ExportTag::kVideo);
+DECLARE_XBOXKRNL_EXPORT1(VdEnableRingBufferRPtrWriteBack, kVideo, kImplemented);
 
 void VdGetSystemCommandBuffer(lpunknown_t p0_ptr, lpunknown_t p1_ptr) {
   p0_ptr.Zero(0x94);
   xe::store_and_swap<uint32_t>(p0_ptr, 0xBEEF0000);
   xe::store_and_swap<uint32_t>(p1_ptr, 0xBEEF0001);
 }
-DECLARE_XBOXKRNL_EXPORT(VdGetSystemCommandBuffer,
-                        ExportTag::kVideo | ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(VdGetSystemCommandBuffer, kVideo, kStub);
 
 void VdSetSystemCommandBufferGpuIdentifierAddress(lpunknown_t unk) {
   // r3 = 0x2B10(d3d?) + 8
 }
-DECLARE_XBOXKRNL_EXPORT(VdSetSystemCommandBufferGpuIdentifierAddress,
-                        ExportTag::kVideo | ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(VdSetSystemCommandBufferGpuIdentifierAddress, kVideo,
+                         kStub);
 
 // VdVerifyMEInitCommand
 // r3
@@ -281,8 +283,8 @@ dword_result_t VdInitializeScalerCommandBuffer(
   }
   return (uint32_t)dest_count;
 }
-DECLARE_XBOXKRNL_EXPORT(VdInitializeScalerCommandBuffer,
-                        ExportTag::kVideo | ExportTag::kSketchy);
+DECLARE_XBOXKRNL_EXPORT2(VdInitializeScalerCommandBuffer, kVideo, kImplemented,
+                         kSketchy);
 
 struct BufferScaling {
   xe::be<uint16_t> fb_width;
@@ -305,15 +307,14 @@ dword_result_t VdCallGraphicsNotificationRoutines(
   // callbacks get 0, r3, r4
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(VdCallGraphicsNotificationRoutines,
-                        ExportTag::kVideo | ExportTag::kSketchy);
+DECLARE_XBOXKRNL_EXPORT2(VdCallGraphicsNotificationRoutines, kVideo,
+                         kImplemented, kSketchy);
 
 dword_result_t VdIsHSIOTrainingSucceeded() {
   // BOOL return value
   return 1;
 }
-DECLARE_XBOXKRNL_EXPORT(VdIsHSIOTrainingSucceeded,
-                        ExportTag::kVideo | ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(VdIsHSIOTrainingSucceeded, kVideo, kStub);
 
 dword_result_t VdPersistDisplay(unknown_t unk0, lpdword_t unk1_ptr) {
   // unk1_ptr needs to be populated with a pointer passed to
@@ -328,18 +329,16 @@ dword_result_t VdPersistDisplay(unknown_t unk0, lpdword_t unk1_ptr) {
 
   return 1;
 }
-DECLARE_XBOXKRNL_EXPORT(VdPersistDisplay,
-                        ExportTag::kVideo | ExportTag::kSketchy);
+DECLARE_XBOXKRNL_EXPORT2(VdPersistDisplay, kVideo, kImplemented, kSketchy);
 
 dword_result_t VdRetrainEDRAMWorker(unknown_t unk0) { return 0; }
-DECLARE_XBOXKRNL_EXPORT(VdRetrainEDRAMWorker,
-                        ExportTag::kVideo | ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(VdRetrainEDRAMWorker, kVideo, kStub);
 
 dword_result_t VdRetrainEDRAM(unknown_t unk0, unknown_t unk1, unknown_t unk2,
                               unknown_t unk3, unknown_t unk4, unknown_t unk5) {
   return 0;
 }
-DECLARE_XBOXKRNL_EXPORT(VdRetrainEDRAM, ExportTag::kVideo | ExportTag::kStub);
+DECLARE_XBOXKRNL_EXPORT1(VdRetrainEDRAM, kVideo, kStub);
 
 void VdSwap(lpvoid_t buffer_ptr,  // ptr into primary ringbuffer
             lpvoid_t fetch_ptr,   // frontbuffer texture fetch
@@ -408,7 +407,7 @@ void VdSwap(lpvoid_t buffer_ptr,  // ptr into primary ringbuffer
     dwords[i] = xenos::MakePacketType2();
   }
 }
-DECLARE_XBOXKRNL_EXPORT(VdSwap, ExportTag::kVideo | ExportTag::kImportant);
+DECLARE_XBOXKRNL_EXPORT2(VdSwap, kVideo, kImplemented, kImportant);
 
 void RegisterVideoExports(xe::cpu::ExportResolver* export_resolver,
                           KernelState* kernel_state) {
diff --git a/src/xenia/kernel/xenumerator.cc b/src/xenia/kernel/xenumerator.cc
index 924b234a1..f60983c97 100644
--- a/src/xenia/kernel/xenumerator.cc
+++ b/src/xenia/kernel/xenumerator.cc
@@ -12,10 +12,10 @@
 namespace xe {
 namespace kernel {
 
-XEnumerator::XEnumerator(KernelState* kernel_state, size_t item_capacity,
+XEnumerator::XEnumerator(KernelState* kernel_state, size_t items_per_enumerate,
                          size_t item_size)
     : XObject(kernel_state, kTypeEnumerator),
-      item_capacity_(item_capacity),
+      items_per_enumerate_(items_per_enumerate),
       item_size_(item_size) {}
 
 XEnumerator::~XEnumerator() = default;
diff --git a/src/xenia/kernel/xenumerator.h b/src/xenia/kernel/xenumerator.h
index 1925895a8..e52048dd8 100644
--- a/src/xenia/kernel/xenumerator.h
+++ b/src/xenia/kernel/xenumerator.h
@@ -23,7 +23,7 @@ class XEnumerator : public XObject {
  public:
   static const Type kType = kTypeEnumerator;
 
-  XEnumerator(KernelState* kernel_state, size_t item_capacity,
+  XEnumerator(KernelState* kernel_state, size_t items_per_enumerate,
               size_t item_size);
   virtual ~XEnumerator();
 
@@ -34,30 +34,28 @@ class XEnumerator : public XObject {
   virtual bool WriteItem(uint8_t* buffer) = 0;
 
   size_t item_size() const { return item_size_; }
+  size_t items_per_enumerate() const { return items_per_enumerate_; }
   size_t current_item() const { return current_item_; }
 
  protected:
-  size_t item_capacity_ = 0;
+  size_t items_per_enumerate_ = 0;
   size_t item_size_ = 0;
   size_t current_item_ = 0;
 };
 
 class XStaticEnumerator : public XEnumerator {
  public:
-  XStaticEnumerator(KernelState* kernel_state, size_t item_capacity,
+  XStaticEnumerator(KernelState* kernel_state, size_t items_per_enumerate,
                     size_t item_size)
-      : XEnumerator(kernel_state, item_capacity, item_size), item_count_(0) {
-    buffer_.resize(item_capacity_ * item_size_);
-  }
+      : XEnumerator(kernel_state, items_per_enumerate, item_size),
+        item_count_(0) {}
 
   uint32_t item_count() const override { return item_count_; }
 
   uint8_t* AppendItem() {
-    if (item_count_ + 1 > item_capacity_) {
-      return nullptr;
-    }
-    auto ptr = const_cast<uint8_t*>(buffer_.data() + item_count_ * item_size_);
-    ++item_count_;
+    buffer_.resize(++item_count_ * item_size_);
+    auto ptr =
+        const_cast<uint8_t*>(buffer_.data() + (item_count_ - 1) * item_size_);
     return ptr;
   }
 
diff --git a/src/xenia/kernel/xevent.h b/src/xenia/kernel/xevent.h
index a0b989461..95ea8613f 100644
--- a/src/xenia/kernel/xevent.h
+++ b/src/xenia/kernel/xevent.h
@@ -17,10 +17,11 @@
 namespace xe {
 namespace kernel {
 
-// http://www.nirsoft.net/kernel_struct/vista/KEVENT.html
+// https://www.nirsoft.net/kernel_struct/vista/KEVENT.html
 struct X_KEVENT {
   X_DISPATCH_HEADER header;
 };
+static_assert_size(X_KEVENT, 0x10);
 
 class XEvent : public XObject {
  public:
diff --git a/src/xenia/kernel/xmodule.h b/src/xenia/kernel/xmodule.h
index 3b085554b..baaf0256f 100644
--- a/src/xenia/kernel/xmodule.h
+++ b/src/xenia/kernel/xmodule.h
@@ -19,7 +19,7 @@
 namespace xe {
 namespace kernel {
 
-// http://www.nirsoft.net/kernel_struct/vista/LDR_DATA_TABLE_ENTRY.html
+// https://www.nirsoft.net/kernel_struct/vista/LDR_DATA_TABLE_ENTRY.html
 // HMODULE points to this struct!
 struct X_LDR_DATA_TABLE_ENTRY {
   X_LIST_ENTRY in_load_order_links;            // 0x0
diff --git a/src/xenia/kernel/xobject.cc b/src/xenia/kernel/xobject.cc
index d5a925fe0..91fad29ce 100644
--- a/src/xenia/kernel/xobject.cc
+++ b/src/xenia/kernel/xobject.cc
@@ -385,7 +385,7 @@ object_ref<XObject> XObject::GetNativeObject(KernelState* kernel_state,
     return object;
   } else {
     // First use, create new.
-    // http://www.nirsoft.net/kernel_struct/vista/KOBJECTS.html
+    // https://www.nirsoft.net/kernel_struct/vista/KOBJECTS.html
     XObject* object = nullptr;
     switch (as_type) {
       case 0:  // EventNotificationObject
diff --git a/src/xenia/kernel/xobject.h b/src/xenia/kernel/xobject.h
index a0ec76050..3ecb908c8 100644
--- a/src/xenia/kernel/xobject.h
+++ b/src/xenia/kernel/xobject.h
@@ -32,7 +32,7 @@ class KernelState;
 template <typename T>
 class object_ref;
 
-// http://www.nirsoft.net/kernel_struct/vista/DISPATCHER_HEADER.html
+// https://www.nirsoft.net/kernel_struct/vista/DISPATCHER_HEADER.html
 typedef struct {
   struct {
     uint8_t type;
@@ -60,7 +60,7 @@ typedef struct {
 } X_DISPATCH_HEADER;
 static_assert_size(X_DISPATCH_HEADER, 0x10);
 
-// http://www.nirsoft.net/kernel_struct/vista/OBJECT_HEADER.html
+// https://www.nirsoft.net/kernel_struct/vista/OBJECT_HEADER.html
 struct X_OBJECT_HEADER {
   xe::be<uint32_t> pointer_count;
   union {
@@ -82,7 +82,7 @@ struct X_OBJECT_HEADER {
   // (There's actually a body field here which is the object itself)
 };
 
-// http://www.nirsoft.net/kernel_struct/vista/OBJECT_CREATE_INFORMATION.html
+// https://www.nirsoft.net/kernel_struct/vista/OBJECT_CREATE_INFORMATION.html
 struct X_OBJECT_CREATE_INFORMATION {
   xe::be<uint32_t> attributes;                  // 0x0
   xe::be<uint32_t> root_directory_ptr;          // 0x4
diff --git a/src/xenia/kernel/xsemaphore.h b/src/xenia/kernel/xsemaphore.h
index 1b0bc5804..42ae7ee26 100644
--- a/src/xenia/kernel/xsemaphore.h
+++ b/src/xenia/kernel/xsemaphore.h
@@ -21,6 +21,7 @@ struct X_KSEMAPHORE {
   X_DISPATCH_HEADER header;
   xe::be<uint32_t> limit;
 };
+static_assert_size(X_KSEMAPHORE, 0x14);
 
 class XSemaphore : public XObject {
  public:
diff --git a/src/xenia/kernel/xsocket.h b/src/xenia/kernel/xsocket.h
index 282001b07..3c85a6c89 100644
--- a/src/xenia/kernel/xsocket.h
+++ b/src/xenia/kernel/xsocket.h
@@ -82,7 +82,7 @@ class XSocket : public XObject {
     IPPROTO_UDP = 17,
 
     // LIVE Voice and Data Protocol
-    // http://blog.csdn.net/baozi3026/article/details/4277227
+    // https://blog.csdn.net/baozi3026/article/details/4277227
     // Format: [cbGameData][GameData(encrypted)][VoiceData(unencrypted)]
     IPPROTO_VDP = 254,
   };
diff --git a/src/xenia/kernel/xthread.cc b/src/xenia/kernel/xthread.cc
index fbb18df02..b5736db57 100644
--- a/src/xenia/kernel/xthread.cc
+++ b/src/xenia/kernel/xthread.cc
@@ -313,7 +313,7 @@ X_STATUS XThread::Create() {
   }
 
   // Allocate thread state block from heap.
-  // http://www.microsoft.com/msj/archive/s2ce.aspx
+  // https://web.archive.org/web/20170704035330/https://www.microsoft.com/msj/archive/S2CE.aspx
   // This is set as r13 for user code and some special inlined Win32 calls
   // (like GetLastError/etc) will poke it directly.
   // We try to use it as our primary store of data just to keep things all
@@ -568,8 +568,8 @@ void XThread::EnqueueApc(uint32_t normal_routine, uint32_t normal_context,
 }
 
 void XThread::DeliverAPCs() {
-  // http://www.drdobbs.com/inside-nts-asynchronous-procedure-call/184416590?pgno=1
-  // http://www.drdobbs.com/inside-nts-asynchronous-procedure-call/184416590?pgno=7
+  // https://www.drdobbs.com/inside-nts-asynchronous-procedure-call/184416590?pgno=1
+  // https://www.drdobbs.com/inside-nts-asynchronous-procedure-call/184416590?pgno=7
   auto processor = kernel_state()->processor();
   LockApc();
   while (apc_list_.HasPending()) {
diff --git a/src/xenia/ui/vulkan/shaders/bin/blit_depth_frag.h b/src/xenia/ui/vulkan/shaders/bin/blit_depth_frag.h
index 0da5a0196..ac499a78f 100644
--- a/src/xenia/ui/vulkan/shaders/bin/blit_depth_frag.h
+++ b/src/xenia/ui/vulkan/shaders/bin/blit_depth_frag.h
@@ -18,53 +18,32 @@ const uint8_t blit_depth_frag[] = {
     0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x0C, 0x00, 0x00, 0x00,
     0x73, 0x72, 0x63, 0x5F, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x00,
     0x05, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x76, 0x74, 0x78, 0x5F,
-    0x75, 0x76, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x19, 0x00, 0x00, 0x00,
-    0x50, 0x75, 0x73, 0x68, 0x43, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74,
-    0x73, 0x00, 0x00, 0x00, 0x06, 0x00, 0x05, 0x00, 0x19, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x5F, 0x70, 0x61, 0x64, 0x00, 0x00, 0x00, 0x00,
-    0x06, 0x00, 0x05, 0x00, 0x19, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x73, 0x77, 0x61, 0x70, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x70, 0x75, 0x73, 0x68, 0x5F, 0x63, 0x6F, 0x6E,
-    0x73, 0x74, 0x61, 0x6E, 0x74, 0x73, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00,
-    0x1D, 0x00, 0x00, 0x00, 0x6F, 0x43, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
-    0x47, 0x00, 0x04, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x05, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x23, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
-    0x19, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
-    0x2C, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00, 0x19, 0x00, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x1D, 0x00, 0x00, 0x00,
-    0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x19, 0x00, 0x09, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x03, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x0A, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x0B, 0x00, 0x00, 0x00,
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
-    0x12, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-    0x15, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00,
-    0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
-    0x17, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x15, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x04, 0x00, 0x19, 0x00, 0x00, 0x00,
-    0x17, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-    0x1A, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
-    0x3B, 0x00, 0x04, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00,
+    0x75, 0x76, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00, 0x1D, 0x00, 0x00, 0x00,
+    0x6F, 0x43, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x0B, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+    0x0C, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x04, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+    0x1D, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x19, 0x00, 0x09, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x03, 0x00, 0x0A, 0x00, 0x00, 0x00,
+    0x09, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x0B, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
+    0x0B, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x04, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x0F, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
+    0x0F, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00,
     0x03, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
     0x1C, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
     0x36, 0x00, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
diff --git a/src/xenia/ui/vulkan/shaders/bin/blit_depth_frag.spv b/src/xenia/ui/vulkan/shaders/bin/blit_depth_frag.spv
index eacc087e2..cb458c810 100644
Binary files a/src/xenia/ui/vulkan/shaders/bin/blit_depth_frag.spv and b/src/xenia/ui/vulkan/shaders/bin/blit_depth_frag.spv differ
diff --git a/src/xenia/ui/vulkan/shaders/bin/blit_depth_frag.txt b/src/xenia/ui/vulkan/shaders/bin/blit_depth_frag.txt
index 8115204b6..e2bd81d13 100644
--- a/src/xenia/ui/vulkan/shaders/bin/blit_depth_frag.txt
+++ b/src/xenia/ui/vulkan/shaders/bin/blit_depth_frag.txt
@@ -14,18 +14,11 @@
                OpName %gl_FragDepth "gl_FragDepth"
                OpName %src_texture "src_texture"
                OpName %vtx_uv "vtx_uv"
-               OpName %PushConstants "PushConstants"
-               OpMemberName %PushConstants 0 "_pad"
-               OpMemberName %PushConstants 1 "swap"
-               OpName %push_constants "push_constants"
                OpName %oC "oC"
                OpDecorate %gl_FragDepth BuiltIn FragDepth
                OpDecorate %src_texture DescriptorSet 0
                OpDecorate %src_texture Binding 0
                OpDecorate %vtx_uv Location 0
-               OpMemberDecorate %PushConstants 0 Offset 32
-               OpMemberDecorate %PushConstants 1 Offset 44
-               OpDecorate %PushConstants Block
                OpDecorate %oC Location 0
        %void = OpTypeVoid
           %3 = OpTypeFunction %void
@@ -40,13 +33,6 @@
 %_ptr_Input_v2float = OpTypePointer Input %v2float
      %vtx_uv = OpVariable %_ptr_Input_v2float Input
     %v4float = OpTypeVector %float 4
-       %uint = OpTypeInt 32 0
-     %uint_0 = OpConstant %uint 0
-    %v3float = OpTypeVector %float 3
-        %int = OpTypeInt 32 1
-%PushConstants = OpTypeStruct %v3float %int
-%_ptr_PushConstant_PushConstants = OpTypePointer PushConstant %PushConstants
-%push_constants = OpVariable %_ptr_PushConstant_PushConstants PushConstant
 %_ptr_Output_v4float = OpTypePointer Output %v4float
          %oC = OpVariable %_ptr_Output_v4float Output
        %main = OpFunction %void None %3
diff --git a/src/xenia/ui/vulkan/shaders/bin/blit_vert.h b/src/xenia/ui/vulkan/shaders/bin/blit_vert.h
index 1524dc49d..f101b89c9 100644
--- a/src/xenia/ui/vulkan/shaders/bin/blit_vert.h
+++ b/src/xenia/ui/vulkan/shaders/bin/blit_vert.h
@@ -11,142 +11,118 @@ const uint8_t blit_vert[] = {
     0x16, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00,
     0x03, 0x00, 0x03, 0x00, 0x02, 0x00, 0x00, 0x00, 0xC2, 0x01, 0x00, 0x00,
     0x05, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00, 0x6D, 0x61, 0x69, 0x6E,
-    0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x76, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5F, 0x70, 0x6F, 0x73, 0x00, 0x00,
-    0x05, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x56,
-    0x65, 0x72, 0x74, 0x65, 0x78, 0x49, 0x6E, 0x64, 0x65, 0x78, 0x00, 0x00,
-    0x05, 0x00, 0x05, 0x00, 0x19, 0x00, 0x00, 0x00, 0x69, 0x6E, 0x64, 0x65,
-    0x78, 0x61, 0x62, 0x6C, 0x65, 0x00, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00,
-    0x1C, 0x00, 0x00, 0x00, 0x73, 0x63, 0x61, 0x6C, 0x65, 0x64, 0x5F, 0x70,
-    0x6F, 0x73, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x24, 0x00, 0x00, 0x00,
-    0x73, 0x63, 0x61, 0x6C, 0x65, 0x64, 0x5F, 0x64, 0x73, 0x74, 0x5F, 0x75,
-    0x76, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x25, 0x00, 0x00, 0x00,
-    0x50, 0x75, 0x73, 0x68, 0x43, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74,
-    0x73, 0x00, 0x00, 0x00, 0x06, 0x00, 0x05, 0x00, 0x25, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x73, 0x72, 0x63, 0x5F, 0x75, 0x76, 0x00, 0x00,
-    0x06, 0x00, 0x05, 0x00, 0x25, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x64, 0x73, 0x74, 0x5F, 0x75, 0x76, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00,
-    0x27, 0x00, 0x00, 0x00, 0x70, 0x75, 0x73, 0x68, 0x5F, 0x63, 0x6F, 0x6E,
-    0x73, 0x74, 0x61, 0x6E, 0x74, 0x73, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00,
-    0x30, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50, 0x65, 0x72, 0x56, 0x65,
-    0x72, 0x74, 0x65, 0x78, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00,
-    0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
-    0x6F, 0x73, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x00, 0x06, 0x00, 0x07, 0x00,
-    0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
-    0x6F, 0x69, 0x6E, 0x74, 0x53, 0x69, 0x7A, 0x65, 0x00, 0x00, 0x00, 0x00,
-    0x06, 0x00, 0x07, 0x00, 0x30, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x67, 0x6C, 0x5F, 0x43, 0x6C, 0x69, 0x70, 0x44, 0x69, 0x73, 0x74, 0x61,
-    0x6E, 0x63, 0x65, 0x00, 0x06, 0x00, 0x07, 0x00, 0x30, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x43, 0x75, 0x6C, 0x6C, 0x44,
-    0x69, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x00, 0x05, 0x00, 0x03, 0x00,
-    0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00,
-    0x42, 0x00, 0x00, 0x00, 0x76, 0x74, 0x78, 0x5F, 0x75, 0x76, 0x00, 0x00,
-    0x47, 0x00, 0x04, 0x00, 0x16, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
-    0x2A, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x25, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x05, 0x00, 0x25, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x23, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00,
-    0x25, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
-    0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x30, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x05, 0x00, 0x30, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x0B, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
-    0x30, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
-    0x04, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00, 0x30, 0x00, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x42, 0x00, 0x00, 0x00,
-    0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x15, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x00, 0x00,
-    0x0B, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00,
-    0x0C, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x80, 0x3F, 0x2C, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00,
-    0x2C, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
-    0x0D, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x05, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
-    0x0F, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x07, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0x13, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x11, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00,
-    0x14, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x14, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00,
-    0x16, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x40, 0x2C, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x1F, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x67, 0x6C, 0x5F, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78, 0x49, 0x6E, 0x64,
+    0x65, 0x78, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x69, 0x6E, 0x64, 0x65, 0x78, 0x61, 0x62, 0x6C, 0x65, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x06, 0x00, 0x25, 0x00, 0x00, 0x00, 0x50, 0x75, 0x73, 0x68,
+    0x43, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74, 0x73, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x05, 0x00, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x73, 0x72, 0x63, 0x5F, 0x75, 0x76, 0x00, 0x00, 0x06, 0x00, 0x05, 0x00,
+    0x25, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0x73, 0x74, 0x5F,
+    0x75, 0x76, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x70, 0x75, 0x73, 0x68, 0x5F, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E,
+    0x74, 0x73, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x67, 0x6C, 0x5F, 0x50, 0x65, 0x72, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78,
+    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50, 0x6F, 0x73, 0x69, 0x74,
+    0x69, 0x6F, 0x6E, 0x00, 0x06, 0x00, 0x07, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50, 0x6F, 0x69, 0x6E, 0x74,
+    0x53, 0x69, 0x7A, 0x65, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x07, 0x00,
+    0x30, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x43,
+    0x6C, 0x69, 0x70, 0x44, 0x69, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x00,
+    0x06, 0x00, 0x07, 0x00, 0x30, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x67, 0x6C, 0x5F, 0x43, 0x75, 0x6C, 0x6C, 0x44, 0x69, 0x73, 0x74, 0x61,
+    0x6E, 0x63, 0x65, 0x00, 0x05, 0x00, 0x03, 0x00, 0x32, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00, 0x42, 0x00, 0x00, 0x00,
+    0x76, 0x74, 0x78, 0x5F, 0x75, 0x76, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
+    0x48, 0x00, 0x05, 0x00, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
+    0x25, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x48, 0x00, 0x05, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x0B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
+    0x30, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x03, 0x00, 0x30, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x04, 0x00, 0x42, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x03, 0x00, 0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00,
+    0x0A, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x0C, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x2C, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
+    0x0D, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F,
+    0x2C, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x0F, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x05, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00,
+    0x0F, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
+    0x2C, 0x00, 0x07, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x0E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
     0x17, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x23, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x04, 0x00,
-    0x25, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x26, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x25, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x26, 0x00, 0x00, 0x00,
-    0x27, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
-    0x14, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x29, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x22, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x07, 0x00, 0x22, 0x00, 0x00, 0x00,
-    0x2C, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
-    0x1E, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
-    0x0A, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x04, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x2E, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x06, 0x00, 0x30, 0x00, 0x00, 0x00,
-    0x22, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00,
-    0x2F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x31, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x31, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x3F, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-    0x41, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x3B, 0x00, 0x04, 0x00, 0x41, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0xF8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x3B, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x23, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
-    0x16, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x19, 0x00, 0x00, 0x00,
-    0x13, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x1A, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x1A, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x1D, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x00,
-    0x1F, 0x00, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x04, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x26, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x04, 0x00, 0x26, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x09, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x28, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x29, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x2C, 0x00, 0x07, 0x00, 0x22, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00,
+    0x1E, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
+    0x1E, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x00, 0x00,
+    0x2E, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00,
+    0x2F, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00,
+    0x1E, 0x00, 0x06, 0x00, 0x30, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x04, 0x00, 0x31, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x30, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x31, 0x00, 0x00, 0x00,
+    0x32, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x04, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x41, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
+    0x41, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x36, 0x00, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x3E, 0x00, 0x03, 0x00, 0x19, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x05, 0x00, 0x08, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00,
     0x41, 0x00, 0x05, 0x00, 0x29, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
     0x27, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
     0x22, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
     0x85, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x24, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x22, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
-    0x4F, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
-    0x34, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x36, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00,
-    0x38, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
-    0x38, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00,
+    0x2D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x83, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
+    0x35, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00,
+    0x2D, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
     0x85, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3A, 0x00, 0x00, 0x00,
-    0x37, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00,
+    0x1B, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00,
     0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
     0x3A, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00,
     0x3C, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -156,22 +132,18 @@ const uint8_t blit_vert[] = {
     0x3D, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
     0x41, 0x00, 0x05, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
     0x32, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x40, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x29, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
-    0x27, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x22, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
-    0x4F, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00,
-    0x45, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x47, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x29, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
-    0x27, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x22, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
-    0x4F, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0x4A, 0x00, 0x00, 0x00,
-    0x49, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x4B, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x4A, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x42, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x00, 0x00,
-    0xFD, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00,
+    0x40, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
+    0x29, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x33, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x45, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00,
+    0x45, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x85, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00,
+    0x1B, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x07, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x4A, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00,
+    0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x81, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x00, 0x00, 0x4A, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0x42, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x00, 0x00, 0xFD, 0x00, 0x01, 0x00,
+    0x38, 0x00, 0x01, 0x00,
 };
diff --git a/src/xenia/ui/vulkan/shaders/bin/blit_vert.spv b/src/xenia/ui/vulkan/shaders/bin/blit_vert.spv
index afaeeb794..f68aabdb8 100644
Binary files a/src/xenia/ui/vulkan/shaders/bin/blit_vert.spv and b/src/xenia/ui/vulkan/shaders/bin/blit_vert.spv differ
diff --git a/src/xenia/ui/vulkan/shaders/bin/blit_vert.txt b/src/xenia/ui/vulkan/shaders/bin/blit_vert.txt
index 5da250bf8..7f423f63d 100644
--- a/src/xenia/ui/vulkan/shaders/bin/blit_vert.txt
+++ b/src/xenia/ui/vulkan/shaders/bin/blit_vert.txt
@@ -9,11 +9,8 @@
                OpEntryPoint Vertex %main "main" %gl_VertexIndex %_ %vtx_uv
                OpSource GLSL 450
                OpName %main "main"
-               OpName %vfetch_pos "vfetch_pos"
                OpName %gl_VertexIndex "gl_VertexIndex"
                OpName %indexable "indexable"
-               OpName %scaled_pos "scaled_pos"
-               OpName %scaled_dst_uv "scaled_dst_uv"
                OpName %PushConstants "PushConstants"
                OpMemberName %PushConstants 0 "src_uv"
                OpMemberName %PushConstants 1 "dst_uv"
@@ -55,9 +52,7 @@
 %gl_VertexIndex = OpVariable %_ptr_Input_int Input
 %_ptr_Function__arr_v2float_uint_4 = OpTypePointer Function %_arr_v2float_uint_4
     %float_2 = OpConstant %float 2
-         %31 = OpConstantComposite %v2float %float_2 %float_2
     %v4float = OpTypeVector %float 4
-%_ptr_Function_v4float = OpTypePointer Function %v4float
 %PushConstants = OpTypeStruct %v4float %v4float
 %_ptr_PushConstant_PushConstants = OpTypePointer PushConstant %PushConstants
 %push_constants = OpVariable %_ptr_PushConstant_PushConstants PushConstant
@@ -75,44 +70,29 @@
      %vtx_uv = OpVariable %_ptr_Output_v2float Output
        %main = OpFunction %void None %3
           %5 = OpLabel
- %vfetch_pos = OpVariable %_ptr_Function_v2float Function
   %indexable = OpVariable %_ptr_Function__arr_v2float_uint_4 Function
- %scaled_pos = OpVariable %_ptr_Function_v2float Function
-%scaled_dst_uv = OpVariable %_ptr_Function_v4float Function
          %23 = OpLoad %int %gl_VertexIndex
                OpStore %indexable %19
          %26 = OpAccessChain %_ptr_Function_v2float %indexable %23
          %27 = OpLoad %v2float %26
-               OpStore %vfetch_pos %27
-         %29 = OpLoad %v2float %vfetch_pos
-         %32 = OpFMul %v2float %29 %31
-         %33 = OpFSub %v2float %32 %18
-               OpStore %scaled_pos %33
          %42 = OpAccessChain %_ptr_PushConstant_v4float %push_constants %int_1
          %43 = OpLoad %v4float %42
          %45 = OpFMul %v4float %43 %44
-               OpStore %scaled_dst_uv %45
-         %52 = OpLoad %v4float %scaled_dst_uv
-         %53 = OpVectorShuffle %v2float %52 %52 0 1
+         %53 = OpVectorShuffle %v2float %45 %45 0 1
          %54 = OpFSub %v2float %53 %18
-         %55 = OpLoad %v2float %vfetch_pos
-         %56 = OpLoad %v4float %scaled_dst_uv
-         %57 = OpVectorShuffle %v2float %56 %56 2 3
-         %58 = OpFMul %v2float %55 %57
+         %57 = OpVectorShuffle %v2float %45 %45 2 3
+         %58 = OpFMul %v2float %27 %57
          %59 = OpFAdd %v2float %54 %58
          %60 = OpCompositeExtract %float %59 0
          %61 = OpCompositeExtract %float %59 1
          %62 = OpCompositeConstruct %v4float %60 %61 %float_0 %float_1
          %64 = OpAccessChain %_ptr_Output_v4float %_ %int_0
                OpStore %64 %62
-         %67 = OpLoad %v2float %vfetch_pos
          %68 = OpAccessChain %_ptr_PushConstant_v4float %push_constants %int_0
          %69 = OpLoad %v4float %68
          %70 = OpVectorShuffle %v2float %69 %69 2 3
-         %71 = OpFMul %v2float %67 %70
-         %72 = OpAccessChain %_ptr_PushConstant_v4float %push_constants %int_0
-         %73 = OpLoad %v4float %72
-         %74 = OpVectorShuffle %v2float %73 %73 0 1
+         %71 = OpFMul %v2float %27 %70
+         %74 = OpVectorShuffle %v2float %69 %69 0 1
          %75 = OpFAdd %v2float %71 %74
                OpStore %vtx_uv %75
                OpReturn
diff --git a/src/xenia/ui/vulkan/shaders/bin/immediate_frag.h b/src/xenia/ui/vulkan/shaders/bin/immediate_frag.h
index 5f45083c7..fe463a1a4 100644
--- a/src/xenia/ui/vulkan/shaders/bin/immediate_frag.h
+++ b/src/xenia/ui/vulkan/shaders/bin/immediate_frag.h
@@ -2,7 +2,7 @@
 // source: immediate.frag
 const uint8_t immediate_frag[] = {
     0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x06, 0x00, 0x08, 0x00,
-    0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
+    0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
     0x01, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00, 0x2B, 0x00, 0x00, 0x00,
     0x0B, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00, 0x47, 0x4C, 0x53, 0x4C,
     0x2E, 0x73, 0x74, 0x64, 0x2E, 0x34, 0x35, 0x30, 0x00, 0x00, 0x00, 0x00,
@@ -25,107 +25,85 @@ const uint8_t immediate_frag[] = {
     0x11, 0x00, 0x00, 0x00, 0x70, 0x75, 0x73, 0x68, 0x5F, 0x63, 0x6F, 0x6E,
     0x73, 0x74, 0x61, 0x6E, 0x74, 0x73, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00,
     0x1C, 0x00, 0x00, 0x00, 0x76, 0x74, 0x78, 0x5F, 0x75, 0x76, 0x00, 0x00,
-    0x05, 0x00, 0x05, 0x00, 0x28, 0x00, 0x00, 0x00, 0x74, 0x65, 0x78, 0x5F,
-    0x63, 0x6F, 0x6C, 0x6F, 0x72, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00,
-    0x2C, 0x00, 0x00, 0x00, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5F,
-    0x73, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x72, 0x00, 0x05, 0x00, 0x04, 0x00,
-    0x36, 0x00, 0x00, 0x00, 0x74, 0x65, 0x78, 0x31, 0x44, 0x00, 0x00, 0x00,
-    0x05, 0x00, 0x04, 0x00, 0x37, 0x00, 0x00, 0x00, 0x74, 0x65, 0x78, 0x32,
-    0x44, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x06, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x74, 0x65, 0x78, 0x74,
+    0x75, 0x72, 0x65, 0x5F, 0x73, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x72, 0x00,
+    0x47, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0B, 0x00, 0x00, 0x00,
+    0x1E, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
+    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+    0x40, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00, 0x0F, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x1C, 0x00, 0x00, 0x00,
     0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x0B, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x48, 0x00, 0x05, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x23, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00,
-    0x0F, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x1C, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x47, 0x00, 0x04, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x2C, 0x00, 0x00, 0x00,
-    0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x36, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x47, 0x00, 0x04, 0x00, 0x36, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x37, 0x00, 0x00, 0x00,
-    0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-    0x37, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-    0x0A, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x3B, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x14, 0x00, 0x02, 0x00, 0x0D, 0x00, 0x00, 0x00,
-    0x15, 0x00, 0x04, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x03, 0x00, 0x0F, 0x00, 0x00, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x04, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x13, 0x00, 0x00, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
-    0x1A, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x1A, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x1B, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00,
-    0x1D, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x2B, 0x00, 0x04, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x1F, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F,
-    0x20, 0x00, 0x04, 0x00, 0x27, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x19, 0x00, 0x09, 0x00, 0x29, 0x00, 0x00, 0x00,
+    0x2C, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x04, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x03, 0x00, 0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
+    0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x00, 0x00,
+    0x0B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x14, 0x00, 0x02, 0x00,
+    0x0D, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x0E, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x03, 0x00,
+    0x0F, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
+    0x3B, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x09, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x0E, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x04, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x1B, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
+    0x1B, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x04, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x1D, 0x00, 0x00, 0x00,
+    0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+    0x1F, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x2B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x80, 0x3F, 0x19, 0x00, 0x09, 0x00, 0x29, 0x00, 0x00, 0x00,
     0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x03, 0x00, 0x2A, 0x00, 0x00, 0x00,
     0x29, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x2B, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
     0x2B, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x19, 0x00, 0x09, 0x00, 0x33, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x1B, 0x00, 0x03, 0x00, 0x34, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00,
-    0x20, 0x00, 0x04, 0x00, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x34, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x35, 0x00, 0x00, 0x00,
-    0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
-    0x2B, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x36, 0x00, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
-    0x05, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x27, 0x00, 0x00, 0x00,
-    0x28, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x13, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
-    0x11, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x0E, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
-    0xAA, 0x00, 0x05, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
-    0x15, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0xA8, 0x00, 0x04, 0x00,
-    0x0D, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
-    0xF7, 0x00, 0x03, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0xFA, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x19, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x18, 0x00, 0x00, 0x00,
-    0x41, 0x00, 0x05, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x1C, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0xBC, 0x00, 0x05, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
-    0x21, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00,
-    0x19, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x19, 0x00, 0x00, 0x00,
-    0xF5, 0x00, 0x07, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
-    0x16, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
-    0x18, 0x00, 0x00, 0x00, 0xF7, 0x00, 0x03, 0x00, 0x26, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x04, 0x00, 0x24, 0x00, 0x00, 0x00,
-    0x25, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
-    0x25, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x2A, 0x00, 0x00, 0x00,
-    0x2D, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x1A, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00,
-    0x57, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00,
-    0x2D, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x28, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
-    0x07, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
-    0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
-    0x09, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
-    0x32, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
-    0x3E, 0x00, 0x03, 0x00, 0x09, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
-    0xF9, 0x00, 0x02, 0x00, 0x26, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00,
-    0x26, 0x00, 0x00, 0x00, 0xFD, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x0C, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0x09, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x0E, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xAA, 0x00, 0x05, 0x00,
+    0x0D, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0xA8, 0x00, 0x04, 0x00, 0x0D, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0xF7, 0x00, 0x03, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x04, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0xF8, 0x00, 0x02, 0x00, 0x18, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
+    0x1F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00,
+    0x1E, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xBC, 0x00, 0x05, 0x00,
+    0x0D, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0xF8, 0x00, 0x02, 0x00, 0x19, 0x00, 0x00, 0x00, 0xF5, 0x00, 0x07, 0x00,
+    0x0D, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0xF7, 0x00, 0x03, 0x00, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xFA, 0x00, 0x04, 0x00, 0x24, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x26, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x3D, 0x00, 0x04, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00,
+    0x2C, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x1A, 0x00, 0x00, 0x00,
+    0x2E, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x57, 0x00, 0x05, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00,
+    0x2E, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x31, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
+    0x2F, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x32, 0x00, 0x00, 0x00, 0xF9, 0x00, 0x02, 0x00, 0x26, 0x00, 0x00, 0x00,
+    0xF8, 0x00, 0x02, 0x00, 0x26, 0x00, 0x00, 0x00, 0xFD, 0x00, 0x01, 0x00,
+    0x38, 0x00, 0x01, 0x00,
 };
diff --git a/src/xenia/ui/vulkan/shaders/bin/immediate_frag.spv b/src/xenia/ui/vulkan/shaders/bin/immediate_frag.spv
index 7e3dda1d6..bfb164d1c 100644
Binary files a/src/xenia/ui/vulkan/shaders/bin/immediate_frag.spv and b/src/xenia/ui/vulkan/shaders/bin/immediate_frag.spv differ
diff --git a/src/xenia/ui/vulkan/shaders/bin/immediate_frag.txt b/src/xenia/ui/vulkan/shaders/bin/immediate_frag.txt
index 343b7f698..68aeadb07 100644
--- a/src/xenia/ui/vulkan/shaders/bin/immediate_frag.txt
+++ b/src/xenia/ui/vulkan/shaders/bin/immediate_frag.txt
@@ -1,7 +1,7 @@
 ; SPIR-V
 ; Version: 1.0
 ; Generator: Khronos Glslang Reference Front End; 6
-; Bound: 56
+; Bound: 51
 ; Schema: 0
                OpCapability Shader
                OpCapability Sampled1D
@@ -17,10 +17,7 @@
                OpMemberName %PushConstants 0 "restrict_texture_samples"
                OpName %push_constants "push_constants"
                OpName %vtx_uv "vtx_uv"
-               OpName %tex_color "tex_color"
                OpName %texture_sampler "texture_sampler"
-               OpName %tex1D "tex1D"
-               OpName %tex2D "tex2D"
                OpDecorate %out_color Location 0
                OpDecorate %vtx_color Location 1
                OpMemberDecorate %PushConstants 0 Offset 64
@@ -28,10 +25,6 @@
                OpDecorate %vtx_uv Location 0
                OpDecorate %texture_sampler DescriptorSet 0
                OpDecorate %texture_sampler Binding 0
-               OpDecorate %tex1D DescriptorSet 0
-               OpDecorate %tex1D Binding 1
-               OpDecorate %tex2D DescriptorSet 0
-               OpDecorate %tex2D Binding 1
        %void = OpTypeVoid
           %3 = OpTypeFunction %void
       %float = OpTypeFloat 32
@@ -54,19 +47,12 @@
      %uint_0 = OpConstant %uint 0
 %_ptr_Input_float = OpTypePointer Input %float
     %float_1 = OpConstant %float 1
-%_ptr_Function_v4float = OpTypePointer Function %v4float
          %41 = OpTypeImage %float 2D 0 0 0 1 Unknown
          %42 = OpTypeSampledImage %41
 %_ptr_UniformConstant_42 = OpTypePointer UniformConstant %42
 %texture_sampler = OpVariable %_ptr_UniformConstant_42 UniformConstant
-         %51 = OpTypeImage %float 1D 0 0 0 1 Unknown
-         %52 = OpTypeSampledImage %51
-%_ptr_UniformConstant_52 = OpTypePointer UniformConstant %52
-      %tex1D = OpVariable %_ptr_UniformConstant_52 UniformConstant
-      %tex2D = OpVariable %_ptr_UniformConstant_42 UniformConstant
        %main = OpFunction %void None %3
           %5 = OpLabel
-  %tex_color = OpVariable %_ptr_Function_v4float Function
          %12 = OpLoad %v4float %vtx_color
                OpStore %out_color %12
          %20 = OpAccessChain %_ptr_PushConstant_int %push_constants %int_0
@@ -88,10 +74,8 @@
          %45 = OpLoad %42 %texture_sampler
          %46 = OpLoad %v2float %vtx_uv
          %47 = OpImageSampleImplicitLod %v4float %45 %46
-               OpStore %tex_color %47
-         %48 = OpLoad %v4float %tex_color
          %49 = OpLoad %v4float %out_color
-         %50 = OpFMul %v4float %49 %48
+         %50 = OpFMul %v4float %49 %47
                OpStore %out_color %50
                OpBranch %38
          %38 = OpLabel
diff --git a/src/xenia/ui/vulkan/shaders/bin/immediate_vert.h b/src/xenia/ui/vulkan/shaders/bin/immediate_vert.h
index 90d42fba1..7a2941e27 100644
--- a/src/xenia/ui/vulkan/shaders/bin/immediate_vert.h
+++ b/src/xenia/ui/vulkan/shaders/bin/immediate_vert.h
@@ -118,10 +118,8 @@ const uint8_t immediate_vert[] = {
     0x0D, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
     0x3D, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
     0x24, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x26, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00,
-    0x23, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00,
-    0x0F, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
-    0x27, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
+    0x26, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00,
+    0x24, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
     0x17, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
     0x3E, 0x00, 0x03, 0x00, 0x29, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00,
     0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00,
diff --git a/src/xenia/ui/vulkan/shaders/bin/immediate_vert.spv b/src/xenia/ui/vulkan/shaders/bin/immediate_vert.spv
index 0b0a9f3cb..a8f672164 100644
Binary files a/src/xenia/ui/vulkan/shaders/bin/immediate_vert.spv and b/src/xenia/ui/vulkan/shaders/bin/immediate_vert.spv differ
diff --git a/src/xenia/ui/vulkan/shaders/bin/immediate_vert.txt b/src/xenia/ui/vulkan/shaders/bin/immediate_vert.txt
index 3ce63ea14..22dc2b353 100644
--- a/src/xenia/ui/vulkan/shaders/bin/immediate_vert.txt
+++ b/src/xenia/ui/vulkan/shaders/bin/immediate_vert.txt
@@ -81,8 +81,7 @@
          %36 = OpAccessChain %_ptr_Output_float %_ %int_0 %uint_1
          %37 = OpLoad %float %36
          %38 = OpFNegate %float %37
-         %39 = OpAccessChain %_ptr_Output_float %_ %int_0 %uint_1
-               OpStore %39 %38
+               OpStore %36 %38
          %43 = OpLoad %v2float %in_uv
                OpStore %vtx_uv %43
          %47 = OpLoad %v4float %in_color
diff --git a/src/xenia/ui/vulkan/vulkan_provider.cc b/src/xenia/ui/vulkan/vulkan_provider.cc
index 5c979f5a1..1e1d005c4 100644
--- a/src/xenia/ui/vulkan/vulkan_provider.cc
+++ b/src/xenia/ui/vulkan/vulkan_provider.cc
@@ -34,8 +34,8 @@ std::unique_ptr<VulkanProvider> VulkanProvider::Create(Window* main_window) {
         "Ensure you have the latest drivers for your GPU and that it "
         "supports Vulkan.\n"
         "\n"
-        "See http://xenia.jp/faq/ for more information and a list of supported "
-        "GPUs.");
+        "See https://xenia.jp/faq/ for more information and a list of "
+        "supported GPUs.");
     return nullptr;
   }
   return provider;
diff --git a/src/xenia/ui/vulkan/vulkan_util.cc b/src/xenia/ui/vulkan/vulkan_util.cc
index 04cae1c24..2682077e5 100644
--- a/src/xenia/ui/vulkan/vulkan_util.cc
+++ b/src/xenia/ui/vulkan/vulkan_util.cc
@@ -403,7 +403,7 @@ void FatalVulkanError(std::string error) {
       "Ensure you have the latest drivers for your GPU and that it supports "
       "Vulkan.\n"
       "\n"
-      "See http://xenia.jp/faq/ for more information and a list of supported "
+      "See https://xenia.jp/faq/ for more information and a list of supported "
       "GPUs.");
 }
 
diff --git a/src/xenia/ui/window_win.cc b/src/xenia/ui/window_win.cc
index 50216fc57..68c13c94b 100644
--- a/src/xenia/ui/window_win.cc
+++ b/src/xenia/ui/window_win.cc
@@ -47,12 +47,20 @@ bool Win32Window::Initialize() { return OnCreate(); }
 bool Win32Window::OnCreate() {
   HINSTANCE hInstance = GetModuleHandle(nullptr);
 
+  if (!SetProcessDpiAwareness_ || !GetDpiForMonitor_) {
+    auto shcore = GetModuleHandle(L"shcore.dll");
+    if (shcore) {
+      SetProcessDpiAwareness_ =
+          GetProcAddress(shcore, "SetProcessDpiAwareness");
+      GetDpiForMonitor_ = GetProcAddress(shcore, "GetDpiForMonitor");
+    }
+  }
+
   static bool has_registered_class = false;
   if (!has_registered_class) {
     // Tell Windows that we're DPI aware.
-    auto spda = (decltype(&SetProcessDpiAwareness))GetProcAddress(
-        GetModuleHandle(L"shcore.dll"), "SetProcessDpiAwareness");
-    if (spda) {
+    if (SetProcessDpiAwareness_) {
+      auto spda = (decltype(&SetProcessDpiAwareness))SetProcessDpiAwareness_;
       auto res = spda(PROCESS_PER_MONITOR_DPI_AWARE);
       if (res != S_OK) {
         XELOGE("Failed to set process DPI awareness. (code = 0x%.8X)", res);
@@ -245,7 +253,7 @@ void Win32Window::ToggleFullscreen(bool fullscreen) {
 
   DWORD style = GetWindowLong(hwnd_, GWL_STYLE);
   if (fullscreen) {
-    // http://blogs.msdn.com/b/oldnewthing/archive/2010/04/12/9994016.aspx
+    // https://blogs.msdn.com/b/oldnewthing/archive/2010/04/12/9994016.aspx
     MONITORINFO mi = {sizeof(mi)};
     if (GetWindowPlacement(hwnd_, &windowed_pos_) &&
         GetMonitorInfo(MonitorFromWindow(hwnd_, MONITOR_DEFAULTTOPRIMARY),
@@ -303,11 +311,16 @@ void Win32Window::set_bordered(bool enabled) {
 }
 
 int Win32Window::get_dpi() const {
+  if (!GetDpiForMonitor_) {
+    return 96;
+  }
+
   HMONITOR monitor = MonitorFromWindow(hwnd_, MONITOR_DEFAULTTOPRIMARY);
 
   // According to msdn, x and y are identical...
   UINT dpi_x, dpi_y;
-  GetDpiForMonitor(monitor, MDT_DEFAULT, &dpi_x, &dpi_y);
+  auto gdfm = (decltype(&GetDpiForMonitor))GetDpiForMonitor_;
+  gdfm(monitor, MDT_DEFAULT, &dpi_x, &dpi_y);
   return dpi_x;
 }
 
diff --git a/src/xenia/ui/window_win.h b/src/xenia/ui/window_win.h
index 1c6373124..d885042ea 100644
--- a/src/xenia/ui/window_win.h
+++ b/src/xenia/ui/window_win.h
@@ -85,6 +85,9 @@ class Win32Window : public Window {
 
   WINDOWPLACEMENT windowed_pos_ = {0};
   POINT last_mouse_pos_ = {0};
+
+  void* SetProcessDpiAwareness_ = nullptr;
+  void* GetDpiForMonitor_ = nullptr;
 };
 
 class Win32MenuItem : public MenuItem {
diff --git a/src/xenia/vfs/devices/stfs_container_device.h b/src/xenia/vfs/devices/stfs_container_device.h
index 28d8105d4..16514761f 100644
--- a/src/xenia/vfs/devices/stfs_container_device.h
+++ b/src/xenia/vfs/devices/stfs_container_device.h
@@ -19,7 +19,7 @@
 namespace xe {
 namespace vfs {
 
-// http://www.free60.org/wiki/STFS
+// https://free60project.github.io/wiki/STFS.html
 
 class StfsContainerEntry;
 
diff --git a/src/xenia/vfs/entry.h b/src/xenia/vfs/entry.h
index 0658ade93..6e6e85dc4 100644
--- a/src/xenia/vfs/entry.h
+++ b/src/xenia/vfs/entry.h
@@ -34,7 +34,7 @@ namespace vfs {
 class Device;
 class File;
 
-// Matches http://source.winehq.org/source/include/winternl.h#1591.
+// Matches https://source.winehq.org/source/include/winternl.h#1591.
 enum class FileAction {
   kSuperseded = 0,
   kOpened = 1,
diff --git a/src/xenia/xbox.h b/src/xenia/xbox.h
index d5e83778e..4884c260e 100644
--- a/src/xenia/xbox.h
+++ b/src/xenia/xbox.h
@@ -27,7 +27,7 @@ typedef uint32_t X_HANDLE;
 // TODO(benvanik): type all of this so we get some safety.
 
 // NT_STATUS (STATUS_*)
-// http://msdn.microsoft.com/en-us/library/cc704588.aspx
+// https://msdn.microsoft.com/en-us/library/cc704588.aspx
 // Adding as needed.
 typedef uint32_t X_STATUS;
 #define XSUCCEEDED(s)     ((s & 0xC0000000) == 0)
@@ -60,6 +60,7 @@ typedef uint32_t X_STATUS;
 #define X_STATUS_OBJECT_NAME_COLLISION                  ((X_STATUS)0xC0000035L)
 #define X_STATUS_INVALID_PAGE_PROTECTION                ((X_STATUS)0xC0000045L)
 #define X_STATUS_MUTANT_NOT_OWNED                       ((X_STATUS)0xC0000046L)
+#define X_STATUS_PROCEDURE_NOT_FOUND                    ((X_STATUS)0xC000007AL)
 #define X_STATUS_INSUFFICIENT_RESOURCES                 ((X_STATUS)0xC000009AL)
 #define X_STATUS_MEMORY_NOT_ALLOCATED                   ((X_STATUS)0xC00000A0L)
 #define X_STATUS_NOT_SUPPORTED                          ((X_STATUS)0xC00000BBL)
@@ -67,6 +68,7 @@ typedef uint32_t X_STATUS;
 #define X_STATUS_INVALID_PARAMETER_2                    ((X_STATUS)0xC00000F0L)
 #define X_STATUS_INVALID_PARAMETER_3                    ((X_STATUS)0xC00000F1L)
 #define X_STATUS_DLL_NOT_FOUND                          ((X_STATUS)0xC0000135L)
+#define X_STATUS_ENTRYPOINT_NOT_FOUND                   ((X_STATUS)0xC0000139L)
 #define X_STATUS_MAPPED_ALIGNMENT                       ((X_STATUS)0xC0000220L)
 #define X_STATUS_NOT_FOUND                              ((X_STATUS)0xC0000225L)
 #define X_STATUS_DRIVER_ORDINAL_NOT_FOUND               ((X_STATUS)0xC0000262L)
@@ -160,7 +162,7 @@ enum X_FILE_ATTRIBUTES : uint32_t {
   X_FILE_ATTRIBUTE_ENCRYPTED = 0x4000,
 };
 
-// http://code.google.com/p/vdash/source/browse/trunk/vdash/include/kernel.h
+// https://github.com/oukiar/vdash/blob/master/vdash/include/kernel.h
 enum X_FILE_INFORMATION_CLASS {
   XFileDirectoryInformation = 1,
   XFileFullDirectoryInformation,
@@ -324,10 +326,10 @@ struct X_UNICODE_STRING {
 };
 static_assert_size(X_UNICODE_STRING, 8);
 
-// http://pastebin.com/SMypYikG
+// https://pastebin.com/SMypYikG
 typedef uint32_t XNotificationID;
 
-// http://ffplay360.googlecode.com/svn/trunk/Common/XTLOnPC.h
+// https://github.com/CodeAsm/ffplay360/blob/master/Common/XTLOnPC.h
 struct X_VIDEO_MODE {
   be<uint32_t> display_width;
   be<uint32_t> display_height;
@@ -361,7 +363,7 @@ struct X_SINGLE_LIST_ENTRY {
 };
 static_assert_size(X_SINGLE_LIST_ENTRY, 4);
 
-// http://www.nirsoft.net/kernel_struct/vista/SLIST_HEADER.html
+// https://www.nirsoft.net/kernel_struct/vista/SLIST_HEADER.html
 struct X_SLIST_HEADER {
   X_SINGLE_LIST_ENTRY next;  // 0x0
   be<uint16_t> depth;        // 0x4
diff --git a/third_party/mspack.lua b/third_party/mspack.lua
new file mode 100644
index 000000000..c1d1b44a5
--- /dev/null
+++ b/third_party/mspack.lua
@@ -0,0 +1,36 @@
+group("third_party")
+project("mspack")
+  uuid("0881692A-75A1-4E7B-87D8-BB9108CEDEA4")
+  kind("StaticLib")
+  language("C++")
+  links({
+    "xenia-base",
+  })
+  defines({
+    "_LIB",
+    "HAVE_CONFIG_H",
+  })
+  removedefines({
+    "_UNICODE",
+    "UNICODE",
+  })
+  includedirs({
+      "mspack",
+  })
+  files({
+      "mspack/logging.cc",
+      "mspack/lzx.h",
+      "mspack/lzxd.c",
+      "mspack/mspack.h",
+      "mspack/readbits.h",
+      "mspack/readhuff.h",
+      "mspack/system.c",
+      "mspack/system.h",
+  })
+
+  filter("platforms:Windows")
+    defines({
+    })
+  filter("platforms:Linux")
+    defines({
+    })
diff --git a/third_party/mspack/COPYING.LIB b/third_party/mspack/COPYING.LIB
new file mode 100644
index 000000000..b1e3f5a26
--- /dev/null
+++ b/third_party/mspack/COPYING.LIB
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/third_party/mspack/config.h b/third_party/mspack/config.h
new file mode 100644
index 000000000..c4d21f9f7
--- /dev/null
+++ b/third_party/mspack/config.h
@@ -0,0 +1,114 @@
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Turn debugging mode on? */
+#undef DEBUG
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#undef HAVE_DLFCN_H
+
+/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */
+#undef HAVE_FSEEKO
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
+/* Define to 1 if you have the `mkdir' function. */
+#undef HAVE_MKDIR
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the `towlower' function. */
+#undef HAVE_TOWLOWER
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Define to 1 if you have the `_mkdir' function. */
+#undef HAVE__MKDIR
+
+/* Define to the sub-directory where libtool stores uninstalled libraries. */
+#undef LT_OBJDIR
+
+/* Define if mkdir takes only one argument. */
+#undef MKDIR_TAKES_ONE_ARG
+
+/* Name of package */
+#undef PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* The size of `off_t', as computed by sizeof. */
+#undef SIZEOF_OFF_T
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS
+
+/* Version number of package */
+#undef VERSION
+
+/* Enable large inode numbers on Mac OS X 10.5.  */
+#ifndef _DARWIN_USE_64_BIT_INODE
+# define _DARWIN_USE_64_BIT_INODE 1
+#endif
+
+/* Number of bits in a file offset, on hosts where this is settable. */
+#undef _FILE_OFFSET_BITS
+
+/* Define to 1 to make fseeko visible on some hosts (e.g. glibc 2.2). */
+#undef _LARGEFILE_SOURCE
+
+/* Define for large files, on AIX-style hosts. */
+#undef _LARGE_FILES
+
+/* Define to empty if `const' does not conform to ANSI C. */
+#undef const
+
+/* Define to `__inline__' or `__inline' if that's what the C compiler
+   calls it, or to nothing if 'inline' is not supported under any name.  */
+#ifndef __cplusplus
+#undef inline
+#endif
+
+/* Define to `int' if <sys/types.h> does not define. */
+#undef mode_t
+
+/* Define to `long int' if <sys/types.h> does not define. */
+#undef off_t
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+#undef size_t
diff --git a/third_party/mspack/logging.cc b/third_party/mspack/logging.cc
new file mode 100644
index 000000000..ae70478d0
--- /dev/null
+++ b/third_party/mspack/logging.cc
@@ -0,0 +1,10 @@
+#include "xenia/base/logging.h"
+
+extern "C" void xenia_log(const char* fmt, ...) {
+  char buffer[128];
+  va_list args;
+  va_start(args, fmt);
+  vsnprintf(buffer, sizeof(buffer), fmt, args);
+  va_end(args);
+  XELOGW("mspack: %s", buffer);
+}
diff --git a/third_party/mspack/lzx.h b/third_party/mspack/lzx.h
index e9eda0fbb..a6152f622 100644
--- a/third_party/mspack/lzx.h
+++ b/third_party/mspack/lzx.h
@@ -1,5 +1,5 @@
 /* This file is part of libmspack.
- * (C) 2003-2004 Stuart Caie.
+ * (C) 2003-2013 Stuart Caie.
  *
  * The LZX method was created by Jonathan Forbes and Tomi Poutanen, adapted
  * by Microsoft Corporation.
@@ -13,6 +13,10 @@
 #ifndef MSPACK_LZX_H
 #define MSPACK_LZX_H 1
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* LZX compression / decompression definitions */
 
 /* some constants defined by the LZX specification */
@@ -31,7 +35,7 @@
 /* LZX huffman defines: tweak tablebits as desired */
 #define LZX_PRETREE_MAXSYMBOLS  (LZX_PRETREE_NUM_ELEMENTS)
 #define LZX_PRETREE_TABLEBITS   (6)
-#define LZX_MAINTREE_MAXSYMBOLS (LZX_NUM_CHARS + 50*8)
+#define LZX_MAINTREE_MAXSYMBOLS (LZX_NUM_CHARS + 290*8)
 #define LZX_MAINTREE_TABLEBITS  (12)
 #define LZX_LENGTH_MAXSYMBOLS   (LZX_NUM_SECONDARY_LENGTHS+1)
 #define LZX_LENGTH_TABLEBITS    (12)
@@ -51,6 +55,8 @@ struct lzxd_stream {
 
   unsigned char *window;          /* decoding window                         */
   unsigned int   window_size;     /* window size                             */
+  unsigned int   ref_data_size;   /* LZX DELTA reference data size           */
+  unsigned int   num_offsets;     /* number of match_offset entries in table */
   unsigned int   window_posn;     /* decompression offset within window      */
   unsigned int   frame_posn;      /* current frame offset within in window   */
   unsigned int   frame;           /* the number of 32kb frames processed     */
@@ -66,8 +72,8 @@ struct lzxd_stream {
   unsigned char  intel_started;   /* has intel E8 decoding started?          */
   unsigned char  block_type;      /* type of the current block               */
   unsigned char  header_read;     /* have we started decoding at all yet?    */
-  unsigned char  posn_slots;      /* how many posn slots in stream?          */
   unsigned char  input_end;       /* have we reached the end of input?       */
+  unsigned char  is_delta;        /* does stream follow LZX DELTA spec?      */
 
   int error;
 
@@ -83,85 +89,133 @@ struct lzxd_stream {
 
   /* huffman decoding tables */
   unsigned short PRETREE_table [(1 << LZX_PRETREE_TABLEBITS) +
-				(LZX_PRETREE_MAXSYMBOLS * 2)];
+                                (LZX_PRETREE_MAXSYMBOLS * 2)];
   unsigned short MAINTREE_table[(1 << LZX_MAINTREE_TABLEBITS) +
-				(LZX_MAINTREE_MAXSYMBOLS * 2)];
+                                (LZX_MAINTREE_MAXSYMBOLS * 2)];
   unsigned short LENGTH_table  [(1 << LZX_LENGTH_TABLEBITS) +
-				(LZX_LENGTH_MAXSYMBOLS * 2)];
+                                (LZX_LENGTH_MAXSYMBOLS * 2)];
   unsigned short ALIGNED_table [(1 << LZX_ALIGNED_TABLEBITS) +
-				(LZX_ALIGNED_MAXSYMBOLS * 2)];
+                                (LZX_ALIGNED_MAXSYMBOLS * 2)];
+  unsigned char LENGTH_empty;
 
   /* this is used purely for doing the intel E8 transform */
   unsigned char  e8_buf[LZX_FRAME_SIZE];
 };
 
-/* allocates LZX decompression state for decoding the given stream.
+/**
+ * Allocates and initialises LZX decompression state for decoding an LZX
+ * stream.
  *
- * - returns NULL if window_bits is outwith the range 15 to 21 (inclusive).
+ * This routine uses system->alloc() to allocate memory. If memory
+ * allocation fails, or the parameters to this function are invalid,
+ * NULL is returned.
  *
- * - uses system->alloc() to allocate memory
- *
- * - returns NULL if not enough memory
- *
- * - window_bits is the size of the LZX window, from 32Kb (15) to 2Mb (21).
- *
- * - reset_interval is how often the bitstream is reset, measured in
- *   multiples of 32Kb bytes output. For CAB LZX streams, this is always 0
- *   (does not occur).
- *
- * - input_buffer_size is how many bytes to use as an input bitstream buffer
- *
- * - output_length is the length in bytes of the entirely decompressed
- *   output stream, if known in advance. It is used to correctly perform
- *   the Intel E8 transformation, which must stop 6 bytes before the very
- *   end of the decompressed stream. It is not otherwise used or adhered
- *   to. If the full decompressed length is known in advance, set it here.
- *   If it is NOT known, use the value 0, and call lzxd_set_output_length()
- *   once it is known. If never set, 4 of the final 6 bytes of the output
- *   stream may be incorrect.
+ * @param system             an mspack_system structure used to read from
+ *                           the input stream and write to the output
+ *                           stream, also to allocate and free memory.
+ * @param input              an input stream with the LZX data.
+ * @param output             an output stream to write the decoded data to.
+ * @param window_bits        the size of the decoding window, which must be
+ *                           between 15 and 21 inclusive for regular LZX
+ *                           data, or between 17 and 25 inclusive for
+ *                           LZX DELTA data.
+ * @param reset_interval     the interval at which the LZX bitstream is
+ *                           reset, in multiples of LZX frames (32678
+ *                           bytes), e.g. a value of 2 indicates the input
+ *                           stream resets after every 65536 output bytes.
+ *                           A value of 0 indicates that the bitstream never
+ *                           resets, such as in CAB LZX streams.
+ * @param input_buffer_size  the number of bytes to use as an input
+ *                           bitstream buffer.
+ * @param output_length      the length in bytes of the entirely
+ *                           decompressed output stream, if known in
+ *                           advance. It is used to correctly perform the
+ *                           Intel E8 transformation, which must stop 6
+ *                           bytes before the very end of the
+ *                           decompressed stream. It is not otherwise used
+ *                           or adhered to. If the full decompressed
+ *                           length is known in advance, set it here.
+ *                           If it is NOT known, use the value 0, and call
+ *                           lzxd_set_output_length() once it is
+ *                           known. If never set, 4 of the final 6 bytes
+ *                           of the output stream may be incorrect.
+ * @param is_delta           should be zero for all regular LZX data,
+ *                           non-zero for LZX DELTA encoded data.
+ * @return a pointer to an initialised lzxd_stream structure, or NULL if
+ * there was not enough memory or parameters to the function were wrong.
  */
 extern struct lzxd_stream *lzxd_init(struct mspack_system *system,
-				     struct mspack_file *input,
-				     struct mspack_file *output,
-				     int window_bits,
-				     int reset_interval,
-				     int input_buffer_size,
-				     off_t output_length);
+                                     struct mspack_file *input,
+                                     struct mspack_file *output,
+                                     int window_bits,
+                                     int reset_interval,
+                                     int input_buffer_size,
+                                     off_t output_length,
+                                     char is_delta);
 
 /* see description of output_length in lzxd_init() */
 extern void lzxd_set_output_length(struct lzxd_stream *lzx,
-				   off_t output_length);
+                                   off_t output_length);
 
-/* decompresses, or decompresses more of, an LZX stream.
+/**
+ * Reads LZX DELTA reference data into the window and allows
+ * lzxd_decompress() to reference it.
  *
- * - out_bytes of data will be decompressed and the function will return
- *   with an MSPACK_ERR_OK return code.
+ * Call this before the first call to lzxd_decompress().
+
+ * @param lzx    the LZX stream to apply this reference data to
+ * @param system an mspack_system implementation to use with the
+ *               input param. Only read() will be called.
+ * @param input  an input file handle to read reference data using
+ *               system->read().
+ * @param length the length of the reference data. Cannot be longer
+ *               than the LZX window size.
+ * @return an error code, or MSPACK_ERR_OK if successful
+ */
+extern int lzxd_set_reference_data(struct lzxd_stream *lzx,
+                                   struct mspack_system *system,
+                                   struct mspack_file *input,
+                                   unsigned int length);
+
+/**
+ * Decompresses entire or partial LZX streams.
  *
- * - decompressing will stop as soon as out_bytes is reached. if the true
- *   amount of bytes decoded spills over that amount, they will be kept for
- *   a later invocation of lzxd_decompress().
+ * The number of bytes of data that should be decompressed is given as the
+ * out_bytes parameter. If more bytes are decoded than are needed, they
+ * will be kept over for a later invocation.
  *
- * - the output bytes will be passed to the system->write() function given in
- *   lzxd_init(), using the output file handle given in lzxd_init(). More
- *   than one call may be made to system->write().
+ * The output bytes will be passed to the system->write() function given in
+ * lzxd_init(), using the output file handle given in lzxd_init(). More than
+ * one call may be made to system->write().
+
+ * Input bytes will be read in as necessary using the system->read()
+ * function given in lzxd_init(), using the input file handle given in
+ * lzxd_init().  This will continue until system->read() returns 0 bytes,
+ * or an error. Errors will be passed out of the function as
+ * MSPACK_ERR_READ errors.  Input streams should convey an "end of input
+ * stream" by refusing to supply all the bytes that LZX asks for when they
+ * reach the end of the stream, rather than return an error code.
  *
- * - LZX will read input bytes as necessary using the system->read() function
- *   given in lzxd_init(), using the input file handle given in lzxd_init().
- *   This will continue until system->read() returns 0 bytes, or an error.
- *   input streams should convey an "end of input stream" by refusing to
- *   supply all the bytes that LZX asks for when they reach the end of the
- *   stream, rather than return an error code.
+ * If any error code other than MSPACK_ERR_OK is returned, the stream
+ * should be considered unusable and lzxd_decompress() should not be
+ * called again on this stream.
  *
- * - if an error code other than MSPACK_ERR_OK is returned, the stream should
- *   be considered unusable and lzxd_decompress() should not be called again
- *   on this stream.
+ * @param lzx       LZX decompression state, as allocated by lzxd_init().
+ * @param out_bytes the number of bytes of data to decompress.
+ * @return an error code, or MSPACK_ERR_OK if successful
  */
 extern int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes);
 
-/* frees all state associated with an LZX data stream
+/**
+ * Frees all state associated with an LZX data stream. This will call
+ * system->free() using the system pointer given in lzxd_init().
  *
- * - calls system->free() using the system pointer given in lzxd_init()
+ * @param lzx LZX decompression state to free.
  */
 void lzxd_free(struct lzxd_stream *lzx);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/third_party/mspack/lzxd.c b/third_party/mspack/lzxd.c
index 2fdf23e80..548366409 100644
--- a/third_party/mspack/lzxd.c
+++ b/third_party/mspack/lzxd.c
@@ -1,5 +1,5 @@
 /* This file is part of libmspack.
- * (C) 2003-2004 Stuart Caie.
+ * (C) 2003-2013 Stuart Caie.
  *
  * The LZX method was created by Jonathan Forbes and Tomi Poutanen, adapted
  * by Microsoft Corporation.
@@ -12,11 +12,16 @@
 
 /* LZX decompression implementation */
 
-#include "mspack.h"
-#include "lzx.h"
+#include <system.h>
+#include <lzx.h>
 
-/* Microsoft's LZX document and their implementation of the
- * com.ms.util.cab Java package do not concur.
+extern void xenia_log(const char*, ...);
+
+#undef D
+#define D(x) do { xenia_log x; } while (0);
+
+/* Microsoft's LZX document (in cab-sdk.exe) and their implementation
+ * of the com.ms.util.cab Java package do not concur.
  *
  * In the LZX document, there is a table showing the correlation between
  * window size and the number of position slots. It states that the 1MB
@@ -58,240 +63,85 @@
  * least one element. However, many CAB files contain blocks where the
  * length tree is completely empty (because there are no matches), and
  * this is expected to succeed.
+ *
+ * The errors in LZX documentation appear have been corrected in the
+ * new documentation for the LZX DELTA format.
+ *
+ *     http://msdn.microsoft.com/en-us/library/cc483133.aspx
+ *
+ * However, this is a different format, an extension of regular LZX.
+ * I have noticed the following differences, there may be more:
+ *
+ * The maximum window size has increased from 2MB to 32MB. This also
+ * increases the maximum number of position slots, etc.
+ *
+ * If the match length is 257 (the maximum possible), this signals
+ * a further length decoding step, that allows for matches up to
+ * 33024 bytes long.
+ *
+ * The format now allows for "reference data", supplied by the caller.
+ * If match offsets go further back than the number of bytes
+ * decompressed so far, that is them accessing the reference data.
  */
 
-
-/* LZX decompressor input macros
- *
- * STORE_BITS        stores bitstream state in lzxd_stream structure
- * RESTORE_BITS      restores bitstream state from lzxd_stream structure
- * READ_BITS(var,n)  takes N bits from the buffer and puts them in var
- * ENSURE_BITS(n)    ensures there are at least N bits in the bit buffer.
- * PEEK_BITS(n)      extracts without removing N bits from the bit buffer
- * REMOVE_BITS(n)    removes N bits from the bit buffer
- *
- * These bit access routines work by using the area beyond the MSB and the
- * LSB as a free source of zeroes when shifting. This avoids having to
- * mask any bits. So we have to know the bit width of the bit buffer
- * variable.
- *
- * The bit buffer datatype should be at least 32 bits wide: it must be
- * possible to ENSURE_BITS(16), so it must be possible to add 16 new bits
- * to the bit buffer when the bit buffer already has 1 to 15 bits left.
- */
-
-#include <limits.h>
-#ifndef CHAR_BIT
-# define CHAR_BIT (8)
-#endif
-#define BITBUF_WIDTH (sizeof(bit_buffer) * CHAR_BIT)
-
-#ifdef LZXDEBUG
-# include <stdio.h>
-# define D(x) do { printf("%s:%d (%s) ",__FILE__, __LINE__, __FUNCTION__); \
-                   printf x ; fputc('\n', stdout); fflush(stdout);} while (0);
-#else
-# define D(x)
-#endif
-
-#define STORE_BITS do {                                                 \
-  lzx->i_ptr      = i_ptr;                                              \
-  lzx->i_end      = i_end;                                              \
-  lzx->bit_buffer = bit_buffer;                                         \
-  lzx->bits_left  = bits_left;                                          \
+/* import bit-reading macros and code */
+#define BITS_TYPE struct lzxd_stream
+#define BITS_VAR lzx
+#define BITS_ORDER_MSB
+#define READ_BYTES do {                 \
+    unsigned char b0, b1;               \
+    READ_IF_NEEDED; b0 = *i_ptr++;      \
+    READ_IF_NEEDED; b1 = *i_ptr++;      \
+    INJECT_BITS((b1 << 8) | b0, 16);    \
 } while (0)
+#include <readbits.h>
 
-#define RESTORE_BITS do {                                               \
-  i_ptr      = lzx->i_ptr;                                              \
-  i_end      = lzx->i_end;                                              \
-  bit_buffer = lzx->bit_buffer;                                         \
-  bits_left  = lzx->bits_left;                                          \
-} while (0)
-
-#define ENSURE_BITS(nbits)                                              \
-  while (bits_left < (nbits)) {                                         \
-    if (i_ptr >= i_end) {                                               \
-      if (lzxd_read_input(lzx)) return lzx->error;                      \
-      i_ptr = lzx->i_ptr;                                               \
-      i_end = lzx->i_end;                                               \
-    }                                                                   \
-    bit_buffer |= ((i_ptr[1] << 8) | i_ptr[0])                          \
-                  << (BITBUF_WIDTH - 16 - bits_left);                   \
-    bits_left  += 16;                                                   \
-    i_ptr      += 2;                                                    \
-  }
-
-#define PEEK_BITS(nbits) (bit_buffer >> (BITBUF_WIDTH - (nbits)))
-
-#define REMOVE_BITS(nbits) ((bit_buffer <<= (nbits)), (bits_left -= (nbits)))
-
-#define READ_BITS(val, nbits) do {                                      \
-  ENSURE_BITS(nbits);                                                   \
-  (val) = PEEK_BITS(nbits);                                             \
-  REMOVE_BITS(nbits);                                                   \
-} while (0)
-
-static int lzxd_read_input(struct lzxd_stream *lzx) {
-  int read = lzx->sys->read(lzx->input, &lzx->inbuf[0], (int)lzx->inbuf_size);
-  if (read < 0) return lzx->error = MSPACK_ERR_READ;
-
-  /* huff decode's ENSURE_BYTES(16) might overrun the input stream, even
-   * if those bits aren't used, so fake 2 more bytes */
-  if (read == 0) {
-    if (lzx->input_end) {
-      D(("out of input bytes"))
-      return lzx->error = MSPACK_ERR_READ;
-    }
-    else {
-      read = 2;
-      lzx->inbuf[0] = lzx->inbuf[1] = 0;
-      lzx->input_end = 1;
-    }
-  }
-
-  lzx->i_ptr = &lzx->inbuf[0];
-  lzx->i_end = &lzx->inbuf[read];
-
-  return MSPACK_ERR_OK;
-}
-
-/* Huffman decoding macros */
-
-/* READ_HUFFSYM(tablename, var) decodes one huffman symbol from the
- * bitstream using the stated table and puts it in var.
- */
-#define READ_HUFFSYM(tbl, var) do {                                     \
-  /* huffman symbols can be up to 16 bits long */                       \
-  ENSURE_BITS(16);                                                      \
-  /* immediate table lookup of [tablebits] bits of the code */          \
-  sym = lzx->tbl##_table[PEEK_BITS(LZX_##tbl##_TABLEBITS)];             \
-  /* is the symbol is longer than [tablebits] bits? (i=node index) */   \
-  if (sym >= LZX_##tbl##_MAXSYMBOLS) {                                  \
-    /* decode remaining bits by tree traversal */                       \
-    i = 1 << (BITBUF_WIDTH - LZX_##tbl##_TABLEBITS);                    \
-    do {                                                                \
-      /* one less bit. error if we run out of bits before decode */     \
-      i >>= 1;                                                          \
-      if (i == 0) {                                                     \
-        D(("out of bits in huffman decode"))                            \
-        return lzx->error = MSPACK_ERR_DECRUNCH;                        \
-      }                                                                 \
-      /* double node index and add 0 (left branch) or 1 (right) */      \
-      sym <<= 1; sym |= (bit_buffer & i) ? 1 : 0;                       \
-      /* hop to next node index / decoded symbol */                     \
-      sym = lzx->tbl##_table[sym];                                      \
-      /* while we are still in node indicies, not decoded symbols */    \
-    } while (sym >= LZX_##tbl##_MAXSYMBOLS);                            \
-  }                                                                     \
-  /* result */                                                          \
-  (var) = sym;                                                          \
-  /* look up the code length of that symbol and discard those bits */   \
-  i = lzx->tbl##_len[sym];                                              \
-  REMOVE_BITS(i);                                                       \
-} while (0)
+/* import huffman-reading macros and code */
+#define TABLEBITS(tbl)      LZX_##tbl##_TABLEBITS
+#define MAXSYMBOLS(tbl)     LZX_##tbl##_MAXSYMBOLS
+#define HUFF_TABLE(tbl,idx) lzx->tbl##_table[idx]
+#define HUFF_LEN(tbl,idx)   lzx->tbl##_len[idx]
+#define HUFF_ERROR          return lzx->error = MSPACK_ERR_DECRUNCH
+#include <readhuff.h>
 
 /* BUILD_TABLE(tbl) builds a huffman lookup table from code lengths */
 #define BUILD_TABLE(tbl)                                                \
-  if (make_decode_table(LZX_##tbl##_MAXSYMBOLS, LZX_##tbl##_TABLEBITS,  \
-			&lzx->tbl##_len[0], &lzx->tbl##_table[0]))      \
-  {                                                                     \
-    D(("failed to build %s table", #tbl))                               \
-    return lzx->error = MSPACK_ERR_DECRUNCH;                            \
-  }
-
-/* make_decode_table(nsyms, nbits, length[], table[])
- *
- * This function was coded by David Tritscher. It builds a fast huffman
- * decoding table from a canonical huffman code lengths table.
- *
- * nsyms  = total number of symbols in this huffman tree.
- * nbits  = any symbols with a code length of nbits or less can be decoded
- *          in one lookup of the table.
- * length = A table to get code lengths from [0 to syms-1]
- * table  = The table to fill up with decoded symbols and pointers.
- *
- * Returns 0 for OK or 1 for error
- */
-
-static int make_decode_table(unsigned int nsyms, unsigned int nbits,
-			     unsigned char *length, unsigned short *table)
-{
-  unsigned short sym;
-  unsigned int leaf, fill;
-  unsigned char bit_num;
-  unsigned int pos         = 0; /* the current position in the decode table */
-  unsigned int table_mask  = 1 << nbits;
-  unsigned int bit_mask    = table_mask >> 1; /* don't do 0 length codes */
-  unsigned int next_symbol = bit_mask; /* base of allocation for long codes */
-
-  /* fill entries for codes short enough for a direct mapping */
-  for (bit_num = 1; bit_num <= nbits; bit_num++) {
-    for (sym = 0; sym < nsyms; sym++) {
-      if (length[sym] != bit_num) continue;
-      leaf = pos;
-      if((pos += bit_mask) > table_mask) return 1; /* table overrun */
-      /* fill all possible lookups of this symbol with the symbol itself */
-      for (fill = bit_mask; fill-- > 0;) table[leaf++] = sym;
+    if (make_decode_table(MAXSYMBOLS(tbl), TABLEBITS(tbl),              \
+                          &HUFF_LEN(tbl,0), &HUFF_TABLE(tbl,0)))        \
+    {                                                                   \
+        D(("failed to build %s table", #tbl))                           \
+        return lzx->error = MSPACK_ERR_DECRUNCH;                        \
     }
-    bit_mask >>= 1;
-  }
-
-  /* full table already? */
-  if (pos == table_mask) return 0;
-
-  /* clear the remainder of the table */
-  for (sym = pos; sym < table_mask; sym++) table[sym] = 0xFFFF;
-
-  /* allow codes to be up to nbits+16 long, instead of nbits */
-  pos <<= 16;
-  table_mask <<= 16;
-  bit_mask = 1 << 15;
-
-  for (bit_num = nbits+1; bit_num <= 16; bit_num++) {
-    for (sym = 0; sym < nsyms; sym++) {
-      if (length[sym] != bit_num) continue;
-
-      leaf = pos >> 16;
-      for (fill = 0; fill < bit_num - nbits; fill++) {
-	/* if this path hasn't been taken yet, 'allocate' two entries */
-	if (table[leaf] == 0xFFFF) {
-	  table[(next_symbol << 1)] = 0xFFFF;
-	  table[(next_symbol << 1) + 1] = 0xFFFF;
-	  table[leaf] = next_symbol++;
-	}
-	/* follow the path and select either left or right for next bit */
-	leaf = table[leaf] << 1;
-	if ((pos >> (15-fill)) & 1) leaf++;
-      }
-      table[leaf] = sym;
-
-      if ((pos += bit_mask) > table_mask) return 1; /* table overflow */
-    }
-    bit_mask >>= 1;
-  }
-
-  /* full table? */
-  if (pos == table_mask) return 0;
-
-  /* either erroneous table, or all elements are 0 - let's find out. */
-  for (sym = 0; sym < nsyms; sym++) if (length[sym]) return 1;
-  return 0;
-}
 
+#define BUILD_TABLE_MAYBE_EMPTY(tbl) do {                               \
+    lzx->tbl##_empty = 0;                                               \
+    if (make_decode_table(MAXSYMBOLS(tbl), TABLEBITS(tbl),              \
+                          &HUFF_LEN(tbl,0), &HUFF_TABLE(tbl,0)))        \
+    {                                                                   \
+        for (i = 0; i < MAXSYMBOLS(tbl); i++) {                         \
+            if (HUFF_LEN(tbl, i) > 0) {                                 \
+                D(("failed to build %s table", #tbl))                   \
+                return lzx->error = MSPACK_ERR_DECRUNCH;                \
+            }                                                           \
+        }                                                               \
+        /* empty tree - allow it, but don't decode symbols with it */   \
+        lzx->tbl##_empty = 1;                                           \
+    }                                                                   \
+} while (0)
 
 /* READ_LENGTHS(tablename, first, last) reads in code lengths for symbols
  * first to last in the given table. The code lengths are stored in their
  * own special LZX way.
  */
-#define READ_LENGTHS(tbl, first, last) do {                            \
-  STORE_BITS;                                                          \
-  if (lzxd_read_lens(lzx, &lzx->tbl##_len[0], (first),                 \
-    (unsigned int)(last))) return lzx->error;                          \
-  RESTORE_BITS;                                                        \
+#define READ_LENGTHS(tbl, first, last) do {             \
+  STORE_BITS;                                           \
+  if (lzxd_read_lens(lzx, &HUFF_LEN(tbl, 0), (first),   \
+    (unsigned int)(last))) return lzx->error;           \
+  RESTORE_BITS;                                         \
 } while (0)
 
 static int lzxd_read_lens(struct lzxd_stream *lzx, unsigned char *lens,
-			  unsigned int first, unsigned int last)
+                          unsigned int first, unsigned int last)
 {
   /* bit buffer and huffman symbol decode variables */
   unsigned int bit_buffer;
@@ -348,27 +198,71 @@ static int lzxd_read_lens(struct lzxd_stream *lzx, unsigned char *lens,
  * a small 'position slot' number and a small offset from that slot are
  * encoded instead of one large offset.
  *
+ * The number of slots is decided by how many are needed to encode the
+ * largest offset for a given window size. This is easy when the gap between
+ * slots is less than 128Kb, it's a linear relationship. But when extra_bits
+ * reaches its limit of 17 (because LZX can only ensure reading 17 bits of
+ * data at a time), we can only jump 128Kb at a time and have to start
+ * using more and more position slots as each window size doubles.
+ *
  * position_base[] is an index to the position slot bases
  *
  * extra_bits[] states how many bits of offset-from-base data is needed.
+ *
+ * They are calculated as follows:
+ * extra_bits[i] = 0 where i < 4
+ * extra_bits[i] = floor(i/2)-1 where i >= 4 && i < 36
+ * extra_bits[i] = 17 where i >= 36
+ * position_base[0] = 0
+ * position_base[i] = position_base[i-1] + (1 << extra_bits[i-1])
  */
-static unsigned int  position_base[51];
-static unsigned char extra_bits[51];
-
-static void lzxd_static_init() {
-  int i, j;
-
-  for (i = 0, j = 0; i < 51; i += 2) {
-    extra_bits[i]   = j; /* 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7... */
-    extra_bits[i+1] = j;
-    if ((i != 0) && (j < 17)) j++; /* 0,0,1,2,3,4...15,16,17,17,17,17... */
-  }
-
-  for (i = 0, j = 0; i < 51; i++) {
-    position_base[i] = j; /* 0,1,2,3,4,6,8,12,16,24,32,... */
-    j += 1 << extra_bits[i]; /* 1,1,1,1,2,2,4,4,8,8,16,16,32,32,... */
-  }
-}
+static const unsigned int position_slots[11] = {
+    30, 32, 34, 36, 38, 42, 50, 66, 98, 162, 290
+};
+static const unsigned char extra_bits[36] = {
+    0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8,
+    9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16
+};
+static const unsigned int position_base[290] = {
+    0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512,
+    768, 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576, 32768,
+    49152, 65536, 98304, 131072, 196608, 262144, 393216, 524288, 655360,
+    786432, 917504, 1048576, 1179648, 1310720, 1441792, 1572864, 1703936,
+    1835008, 1966080, 2097152, 2228224, 2359296, 2490368, 2621440, 2752512,
+    2883584, 3014656, 3145728, 3276800, 3407872, 3538944, 3670016, 3801088,
+    3932160, 4063232, 4194304, 4325376, 4456448, 4587520, 4718592, 4849664,
+    4980736, 5111808, 5242880, 5373952, 5505024, 5636096, 5767168, 5898240,
+    6029312, 6160384, 6291456, 6422528, 6553600, 6684672, 6815744, 6946816,
+    7077888, 7208960, 7340032, 7471104, 7602176, 7733248, 7864320, 7995392,
+    8126464, 8257536, 8388608, 8519680, 8650752, 8781824, 8912896, 9043968,
+    9175040, 9306112, 9437184, 9568256, 9699328, 9830400, 9961472, 10092544,
+    10223616, 10354688, 10485760, 10616832, 10747904, 10878976, 11010048,
+    11141120, 11272192, 11403264, 11534336, 11665408, 11796480, 11927552,
+    12058624, 12189696, 12320768, 12451840, 12582912, 12713984, 12845056,
+    12976128, 13107200, 13238272, 13369344, 13500416, 13631488, 13762560,
+    13893632, 14024704, 14155776, 14286848, 14417920, 14548992, 14680064,
+    14811136, 14942208, 15073280, 15204352, 15335424, 15466496, 15597568,
+    15728640, 15859712, 15990784, 16121856, 16252928, 16384000, 16515072,
+    16646144, 16777216, 16908288, 17039360, 17170432, 17301504, 17432576,
+    17563648, 17694720, 17825792, 17956864, 18087936, 18219008, 18350080,
+    18481152, 18612224, 18743296, 18874368, 19005440, 19136512, 19267584,
+    19398656, 19529728, 19660800, 19791872, 19922944, 20054016, 20185088,
+    20316160, 20447232, 20578304, 20709376, 20840448, 20971520, 21102592,
+    21233664, 21364736, 21495808, 21626880, 21757952, 21889024, 22020096,
+    22151168, 22282240, 22413312, 22544384, 22675456, 22806528, 22937600,
+    23068672, 23199744, 23330816, 23461888, 23592960, 23724032, 23855104,
+    23986176, 24117248, 24248320, 24379392, 24510464, 24641536, 24772608,
+    24903680, 25034752, 25165824, 25296896, 25427968, 25559040, 25690112,
+    25821184, 25952256, 26083328, 26214400, 26345472, 26476544, 26607616,
+    26738688, 26869760, 27000832, 27131904, 27262976, 27394048, 27525120,
+    27656192, 27787264, 27918336, 28049408, 28180480, 28311552, 28442624,
+    28573696, 28704768, 28835840, 28966912, 29097984, 29229056, 29360128,
+    29491200, 29622272, 29753344, 29884416, 30015488, 30146560, 30277632,
+    30408704, 30539776, 30670848, 30801920, 30932992, 31064064, 31195136,
+    31326208, 31457280, 31588352, 31719424, 31850496, 31981568, 32112640,
+    32243712, 32374784, 32505856, 32636928, 32768000, 32899072, 33030144,
+    33161216, 33292288, 33423360
+};
 
 static void lzxd_reset_state(struct lzxd_stream *lzx) {
   int i;
@@ -388,35 +282,46 @@ static void lzxd_reset_state(struct lzxd_stream *lzx) {
 /*-------- main LZX code --------*/
 
 struct lzxd_stream *lzxd_init(struct mspack_system *system,
-			      struct mspack_file *input,
-			      struct mspack_file *output,
-			      int window_bits,
-			      int reset_interval,
-			      int input_buffer_size,
-			      off_t output_length)
+                              struct mspack_file *input,
+                              struct mspack_file *output,
+                              int window_bits,
+                              int reset_interval,
+                              int input_buffer_size,
+                              off_t output_length,
+                              char is_delta)
 {
   unsigned int window_size = 1 << window_bits;
   struct lzxd_stream *lzx;
 
   if (!system) return NULL;
 
-  /* LZX supports window sizes of 2^15 (32Kb) through 2^21 (2Mb) */
-  if (window_bits < 15 || window_bits > 21) return NULL;
+  /* LZX DELTA window sizes are between 2^17 (128KiB) and 2^25 (32MiB),
+   * regular LZX windows are between 2^15 (32KiB) and 2^21 (2MiB)
+   */
+  if (is_delta) {
+      if (window_bits < 17 || window_bits > 25) return NULL;
+  }
+  else {
+      if (window_bits < 15 || window_bits > 21) return NULL;
+  }
 
+  if (reset_interval < 0 || output_length < 0) {
+      D(("reset interval or output length < 0"))
+      return NULL;
+  }
+
+  /* round up input buffer size to multiple of two */
   input_buffer_size = (input_buffer_size + 1) & -2;
-  if (!input_buffer_size) return NULL;
-
-  /* initialise static data */
-  lzxd_static_init();
+  if (input_buffer_size < 2) return NULL;
 
   /* allocate decompression state */
-  if (!(lzx = (struct lzxd_stream *)system->alloc(system, sizeof(struct lzxd_stream)))) {
+  if (!(lzx = (struct lzxd_stream *) system->alloc(system, sizeof(struct lzxd_stream)))) {
     return NULL;
   }
 
   /* allocate decompression window and input buffer */
-  lzx->window = (unsigned char *)system->alloc(system, (size_t) window_size);
-  lzx->inbuf  = (unsigned char *)system->alloc(system, (size_t) input_buffer_size);
+  lzx->window = (unsigned char *) system->alloc(system, (size_t) window_size);
+  lzx->inbuf  = (unsigned char *) system->alloc(system, (size_t) input_buffer_size);
   if (!lzx->window || !lzx->inbuf) {
     system->free(lzx->window);
     system->free(lzx->inbuf);
@@ -433,43 +338,73 @@ struct lzxd_stream *lzxd_init(struct mspack_system *system,
 
   lzx->inbuf_size      = input_buffer_size;
   lzx->window_size     = 1 << window_bits;
+  lzx->ref_data_size   = 0;
   lzx->window_posn     = 0;
   lzx->frame_posn      = 0;
   lzx->frame           = 0;
   lzx->reset_interval  = reset_interval;
   lzx->intel_filesize  = 0;
   lzx->intel_curpos    = 0;
-
-  /* window bits:    15  16  17  18  19  20  21
-   * position slots: 30  32  34  36  38  42  50  */
-  lzx->posn_slots      = ((window_bits == 21) ? 50 :
-			  ((window_bits == 20) ? 42 : (window_bits << 1)));
   lzx->intel_started   = 0;
-  lzx->input_end       = 0;
+  lzx->error           = MSPACK_ERR_OK;
+  lzx->num_offsets     = position_slots[window_bits - 15] << 3;
+  lzx->is_delta        = is_delta;
 
-  lzx->error = MSPACK_ERR_OK;
-
-  lzx->i_ptr = lzx->i_end = &lzx->inbuf[0];
   lzx->o_ptr = lzx->o_end = &lzx->e8_buf[0];
-  lzx->bit_buffer = lzx->bits_left = 0;
-
   lzxd_reset_state(lzx);
+  INIT_BITS;
   return lzx;
 }
 
+int lzxd_set_reference_data(struct lzxd_stream *lzx,
+                            struct mspack_system *system,
+                            struct mspack_file *input,
+                            unsigned int length)
+{
+    if (!lzx) return MSPACK_ERR_ARGS;
+
+    if (!lzx->is_delta) {
+        D(("only LZX DELTA streams support reference data"))
+        return MSPACK_ERR_ARGS;
+    }
+    if (lzx->offset) {
+        D(("too late to set reference data after decoding starts"))
+        return MSPACK_ERR_ARGS;
+    }
+    if (length > lzx->window_size) {
+        D(("reference length (%u) is longer than the window", length))
+        return MSPACK_ERR_ARGS;
+    }
+    if (length > 0 && (!system || !input)) {
+        D(("length > 0 but no system or input"))
+        return MSPACK_ERR_ARGS;
+    }
+
+    lzx->ref_data_size = length;
+    if (length > 0) {
+        /* copy reference data */
+        unsigned char *pos = &lzx->window[lzx->window_size - length];
+        int bytes = system->read(input, pos, length);
+        /* length can't be more than 2^25, so no signedness problem */
+        if (bytes < (int)length) return MSPACK_ERR_READ;
+    }
+    lzx->ref_data_size = length;
+    return MSPACK_ERR_OK;
+}
+
 void lzxd_set_output_length(struct lzxd_stream *lzx, off_t out_bytes) {
-  if (lzx) lzx->length = out_bytes;
+  if (lzx && out_bytes > 0) lzx->length = out_bytes;
 }
 
 int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
-  /* bitstream reading and huffman variables */
+  /* bitstream and huffman reading variables */
   unsigned int bit_buffer;
   int bits_left, i=0;
-  unsigned short sym;
   unsigned char *i_ptr, *i_end;
+  unsigned short sym;
 
   int match_length, length_footer, extra, verbatim_bits, bytes_todo;
-  int this_run, main_element, aligned_bits, j;
+  int this_run, main_element, aligned_bits, j, warned = 0;
   unsigned char *window, *runsrc, *rundest, buf[12];
   unsigned int frame_size=0, end_frame, match_offset, window_posn;
   unsigned int R0, R1, R2;
@@ -505,12 +440,25 @@ int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
     /* have we reached the reset interval? (if there is one?) */
     if (lzx->reset_interval && ((lzx->frame % lzx->reset_interval) == 0)) {
       if (lzx->block_remaining) {
-	D(("%d bytes remaining at reset interval", lzx->block_remaining))
-	return lzx->error = MSPACK_ERR_DECRUNCH;
+        /* this is a file format error, we can make a best effort to extract what we can */
+        D(("%d bytes remaining at reset interval", lzx->block_remaining))
+        if (!warned) {
+          lzx->sys->message(NULL, "WARNING; invalid reset interval detected during LZX decompression");
+          warned++;
+        }
       }
 
       /* re-read the intel header and reset the huffman lengths */
       lzxd_reset_state(lzx);
+      R0 = lzx->R0;
+      R1 = lzx->R1;
+      R2 = lzx->R2;
+    }
+
+    /* LZX DELTA format has chunk_size, not present in LZX format */
+    if (lzx->is_delta) {
+      ENSURE_BITS(16);
+      REMOVE_BITS(16);
     }
 
     /* read header if necessary */
@@ -527,7 +475,7 @@ int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
      * has been filled in. */
     frame_size = LZX_FRAME_SIZE;
     if (lzx->length && (lzx->length - lzx->offset) < (off_t)frame_size) {
-      frame_size = (unsigned int)(lzx->length - lzx->offset);
+      frame_size = lzx->length - lzx->offset;
     }
 
     /* decode until one more frame is available */
@@ -535,70 +483,61 @@ int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
     while (bytes_todo > 0) {
       /* initialise new block, if one is needed */
       if (lzx->block_remaining == 0) {
-	/* realign if previous block was an odd-sized UNCOMPRESSED block */
-	if ((lzx->block_type == LZX_BLOCKTYPE_UNCOMPRESSED) &&
-	    (lzx->block_length & 1))
-	{
-	  if (i_ptr == i_end) {
-	    if (lzxd_read_input(lzx)) return lzx->error;
-	    i_ptr = lzx->i_ptr;
-	    i_end = lzx->i_end;
-	  }
-	  i_ptr++;
-	}
+        /* realign if previous block was an odd-sized UNCOMPRESSED block */
+        if ((lzx->block_type == LZX_BLOCKTYPE_UNCOMPRESSED) &&
+            (lzx->block_length & 1))
+        {
+          READ_IF_NEEDED;
+          i_ptr++;
+        }
 
-	/* read block type (3 bits) and block length (24 bits) */
-	READ_BITS(lzx->block_type, 3);
-	READ_BITS(i, 16); READ_BITS(j, 8);
-	lzx->block_remaining = lzx->block_length = (i << 8) | j;
-	/*D(("new block t%d len %u", lzx->block_type, lzx->block_length))*/
+        /* read block type (3 bits) and block length (24 bits) */
+        READ_BITS(lzx->block_type, 3);
+        READ_BITS(i, 16); READ_BITS(j, 8);
+        lzx->block_remaining = lzx->block_length = (i << 8) | j;
+        /*D(("new block t%d len %u", lzx->block_type, lzx->block_length))*/
 
-	/* read individual block headers */
-	switch (lzx->block_type) {
-	case LZX_BLOCKTYPE_ALIGNED:
-	  /* read lengths of and build aligned huffman decoding tree */
-	  for (i = 0; i < 8; i++) { READ_BITS(j, 3); lzx->ALIGNED_len[i] = j; }
-	  BUILD_TABLE(ALIGNED);
-	  /* no break -- rest of aligned header is same as verbatim */
-	case LZX_BLOCKTYPE_VERBATIM:
-	  /* read lengths of and build main huffman decoding tree */
-	  READ_LENGTHS(MAINTREE, 0, 256);
-	  READ_LENGTHS(MAINTREE, 256, LZX_NUM_CHARS + (lzx->posn_slots << 3));
-	  BUILD_TABLE(MAINTREE);
-	  /* if the literal 0xE8 is anywhere in the block... */
-	  if (lzx->MAINTREE_len[0xE8] != 0) lzx->intel_started = 1;
-	  /* read lengths of and build lengths huffman decoding tree */
-	  READ_LENGTHS(LENGTH, 0, LZX_NUM_SECONDARY_LENGTHS);
-	  BUILD_TABLE(LENGTH);
-	  break;
+        /* read individual block headers */
+        switch (lzx->block_type) {
+        case LZX_BLOCKTYPE_ALIGNED:
+          /* read lengths of and build aligned huffman decoding tree */
+          for (i = 0; i < 8; i++) { READ_BITS(j, 3); lzx->ALIGNED_len[i] = j; }
+          BUILD_TABLE(ALIGNED);
+          /* rest of aligned header is same as verbatim */ /*@fallthrough@*/
+        case LZX_BLOCKTYPE_VERBATIM:
+          /* read lengths of and build main huffman decoding tree */
+          READ_LENGTHS(MAINTREE, 0, 256);
+          READ_LENGTHS(MAINTREE, 256, LZX_NUM_CHARS + lzx->num_offsets);
+          BUILD_TABLE(MAINTREE);
+          /* if the literal 0xE8 is anywhere in the block... */
+          if (lzx->MAINTREE_len[0xE8] != 0) lzx->intel_started = 1;
+          /* read lengths of and build lengths huffman decoding tree */
+          READ_LENGTHS(LENGTH, 0, LZX_NUM_SECONDARY_LENGTHS);
+          BUILD_TABLE_MAYBE_EMPTY(LENGTH);
+          break;
 
-	case LZX_BLOCKTYPE_UNCOMPRESSED:
-	  /* because we can't assume otherwise */
-	  lzx->intel_started = 1;
+        case LZX_BLOCKTYPE_UNCOMPRESSED:
+          /* because we can't assume otherwise */
+          lzx->intel_started = 1;
 
-	  /* read 1-16 (not 0-15) bits to align to bytes */
-	  ENSURE_BITS(16);
-	  if (bits_left > 16) i_ptr -= 2;
-	  bits_left = 0; bit_buffer = 0;
+          /* read 1-16 (not 0-15) bits to align to bytes */
+          if (bits_left == 0) ENSURE_BITS(16);
+          bits_left = 0; bit_buffer = 0;
 
-	  /* read 12 bytes of stored R0 / R1 / R2 values */
-	  for (rundest = &buf[0], i = 0; i < 12; i++) {
-	    if (i_ptr == i_end) {
-	      if (lzxd_read_input(lzx)) return lzx->error;
-	      i_ptr = lzx->i_ptr;
-	      i_end = lzx->i_end;
-	    }
-	    *rundest++ = *i_ptr++;
-	  }
-	  R0 = buf[0] | (buf[1] << 8) | (buf[2]  << 16) | (buf[3]  << 24);
-	  R1 = buf[4] | (buf[5] << 8) | (buf[6]  << 16) | (buf[7]  << 24);
-	  R2 = buf[8] | (buf[9] << 8) | (buf[10] << 16) | (buf[11] << 24);
-	  break;
+          /* read 12 bytes of stored R0 / R1 / R2 values */
+          for (rundest = &buf[0], i = 0; i < 12; i++) {
+            READ_IF_NEEDED;
+            *rundest++ = *i_ptr++;
+          }
+          R0 = buf[0] | (buf[1] << 8) | (buf[2]  << 16) | (buf[3]  << 24);
+          R1 = buf[4] | (buf[5] << 8) | (buf[6]  << 16) | (buf[7]  << 24);
+          R2 = buf[8] | (buf[9] << 8) | (buf[10] << 16) | (buf[11] << 24);
+          break;
 
-	default:
-	  D(("bad block type"))
-	  return lzx->error = MSPACK_ERR_DECRUNCH;
-	}
+        default:
+          D(("bad block type"))
+          return lzx->error = MSPACK_ERR_DECRUNCH;
+        }
       }
 
       /* decode more of the block:
@@ -613,202 +552,270 @@ int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
       /* decode at least this_run bytes */
       switch (lzx->block_type) {
       case LZX_BLOCKTYPE_VERBATIM:
-	while (this_run > 0) {
-	  READ_HUFFSYM(MAINTREE, main_element);
-	  if (main_element < LZX_NUM_CHARS) {
-	    /* literal: 0 to LZX_NUM_CHARS-1 */
-	    window[window_posn++] = main_element;
-	    this_run--;
-	  }
-	  else {
-	    /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
-	    main_element -= LZX_NUM_CHARS;
+        while (this_run > 0) {
+          READ_HUFFSYM(MAINTREE, main_element);
+          if (main_element < LZX_NUM_CHARS) {
+            /* literal: 0 to LZX_NUM_CHARS-1 */
+            window[window_posn++] = main_element;
+            this_run--;
+          }
+          else {
+            /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
+            main_element -= LZX_NUM_CHARS;
 
-	    /* get match length */
-	    match_length = main_element & LZX_NUM_PRIMARY_LENGTHS;
-	    if (match_length == LZX_NUM_PRIMARY_LENGTHS) {
-	      READ_HUFFSYM(LENGTH, length_footer);
-	      match_length += length_footer;
-	    }
-	    match_length += LZX_MIN_MATCH;
-	  
-	    /* get match offset */
-	    switch ((match_offset = (main_element >> 3))) {
-	    case 0: match_offset = R0;                                  break;
-	    case 1: match_offset = R1; R1=R0;        R0 = match_offset; break;
-	    case 2: match_offset = R2; R2=R0;        R0 = match_offset; break;
-	    case 3: match_offset = 1;  R2=R1; R1=R0; R0 = match_offset; break;
-	    default:
-	      extra = extra_bits[match_offset];
-	      READ_BITS(verbatim_bits, extra);
-	      match_offset = position_base[match_offset] - 2 + verbatim_bits;
-	      R2 = R1; R1 = R0; R0 = match_offset;
-	    }
+            /* get match length */
+            match_length = main_element & LZX_NUM_PRIMARY_LENGTHS;
+            if (match_length == LZX_NUM_PRIMARY_LENGTHS) {
+              if (lzx->LENGTH_empty) {
+                D(("LENGTH symbol needed but tree is empty"))
+                return lzx->error = MSPACK_ERR_DECRUNCH;
+              }
+              READ_HUFFSYM(LENGTH, length_footer);
+              match_length += length_footer;
+            }
+            match_length += LZX_MIN_MATCH;
 
-	    if ((window_posn + match_length) > lzx->window_size) {
-	      D(("match ran over window wrap"))
-	      return lzx->error = MSPACK_ERR_DECRUNCH;
-	    }
-	    
-	    /* copy match */
-	    rundest = &window[window_posn];
-	    i = match_length;
-	    /* does match offset wrap the window? */
-	    if (match_offset > window_posn) {
-	      /* j = length from match offset to end of window */
-	      j = match_offset - window_posn;
-	      if (j > (int) lzx->window_size) {
-		D(("match offset beyond window boundaries"))
-		return lzx->error = MSPACK_ERR_DECRUNCH;
-	      }
-	      runsrc = &window[lzx->window_size - j];
-	      if (j < i) {
-		/* if match goes over the window edge, do two copy runs */
-		i -= j; while (j-- > 0) *rundest++ = *runsrc++;
-		runsrc = window;
-	      }
-	      while (i-- > 0) *rundest++ = *runsrc++;
-	    }
-	    else {
-	      runsrc = rundest - match_offset;
-	      while (i-- > 0) *rundest++ = *runsrc++;
-	    }
+            /* get match offset */
+            switch ((match_offset = (main_element >> 3))) {
+            case 0: match_offset = R0;                                  break;
+            case 1: match_offset = R1; R1=R0;        R0 = match_offset; break;
+            case 2: match_offset = R2; R2=R0;        R0 = match_offset; break;
+            case 3: match_offset = 1;  R2=R1; R1=R0; R0 = match_offset; break;
+            default:
+              extra = (match_offset >= 36) ? 17 : extra_bits[match_offset];
+              READ_BITS(verbatim_bits, extra);
+              match_offset = position_base[match_offset] - 2 + verbatim_bits;
+              R2 = R1; R1 = R0; R0 = match_offset;
+            }
 
-	    this_run    -= match_length;
-	    window_posn += match_length;
-	  }
-	} /* while (this_run > 0) */
-	break;
+            /* LZX DELTA uses max match length to signal even longer match */
+            if (match_length == LZX_MAX_MATCH && lzx->is_delta) {
+                int extra_len = 0;
+                ENSURE_BITS(3); /* 4 entry huffman tree */
+                if (PEEK_BITS(1) == 0) {
+                    REMOVE_BITS(1); /* '0' -> 8 extra length bits */
+                    READ_BITS(extra_len, 8);
+                }
+                else if (PEEK_BITS(2) == 2) {
+                    REMOVE_BITS(2); /* '10' -> 10 extra length bits + 0x100 */
+                    READ_BITS(extra_len, 10);
+                    extra_len += 0x100;
+                }
+                else if (PEEK_BITS(3) == 6) {
+                    REMOVE_BITS(3); /* '110' -> 12 extra length bits + 0x500 */
+                    READ_BITS(extra_len, 12);
+                    extra_len += 0x500;
+                }
+                else {
+                    REMOVE_BITS(3); /* '111' -> 15 extra length bits */
+                    READ_BITS(extra_len, 15);
+                }
+                match_length += extra_len;
+            }
+
+            if ((window_posn + match_length) > lzx->window_size) {
+              D(("match ran over window wrap"))
+              return lzx->error = MSPACK_ERR_DECRUNCH;
+            }
+            
+            /* copy match */
+            rundest = &window[window_posn];
+            i = match_length;
+            /* does match offset wrap the window? */
+            if (match_offset > window_posn) {
+              if ((off_t)match_offset > lzx->offset &&
+                  (match_offset - window_posn) > lzx->ref_data_size)
+              {
+                D(("match offset beyond LZX stream"))
+                return lzx->error = MSPACK_ERR_DECRUNCH;
+              }
+              /* j = length from match offset to end of window */
+              j = match_offset - window_posn;
+              if (j > (int) lzx->window_size) {
+                D(("match offset beyond window boundaries"))
+                return lzx->error = MSPACK_ERR_DECRUNCH;
+              }
+              runsrc = &window[lzx->window_size - j];
+              if (j < i) {
+                /* if match goes over the window edge, do two copy runs */
+                i -= j; while (j-- > 0) *rundest++ = *runsrc++;
+                runsrc = window;
+              }
+              while (i-- > 0) *rundest++ = *runsrc++;
+            }
+            else {
+              runsrc = rundest - match_offset;
+              while (i-- > 0) *rundest++ = *runsrc++;
+            }
+
+            this_run    -= match_length;
+            window_posn += match_length;
+          }
+        } /* while (this_run > 0) */
+        break;
 
       case LZX_BLOCKTYPE_ALIGNED:
-	while (this_run > 0) {
-	  READ_HUFFSYM(MAINTREE, main_element);
-	  if (main_element < LZX_NUM_CHARS) {
-	    /* literal: 0 to LZX_NUM_CHARS-1 */
-	    window[window_posn++] = main_element;
-	    this_run--;
-	  }
-	  else {
-	    /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
-	    main_element -= LZX_NUM_CHARS;
+        while (this_run > 0) {
+          READ_HUFFSYM(MAINTREE, main_element);
+          if (main_element < LZX_NUM_CHARS) {
+            /* literal: 0 to LZX_NUM_CHARS-1 */
+            window[window_posn++] = main_element;
+            this_run--;
+          }
+          else {
+            /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
+            main_element -= LZX_NUM_CHARS;
 
-	    /* get match length */
-	    match_length = main_element & LZX_NUM_PRIMARY_LENGTHS;
-	    if (match_length == LZX_NUM_PRIMARY_LENGTHS) {
-	      READ_HUFFSYM(LENGTH, length_footer);
-	      match_length += length_footer;
-	    }
-	    match_length += LZX_MIN_MATCH;
+            /* get match length */
+            match_length = main_element & LZX_NUM_PRIMARY_LENGTHS;
+            if (match_length == LZX_NUM_PRIMARY_LENGTHS) {
+              if (lzx->LENGTH_empty) {
+                D(("LENGTH symbol needed but tree is empty"))
+                return lzx->error = MSPACK_ERR_DECRUNCH;
+              } 
+              READ_HUFFSYM(LENGTH, length_footer);
+              match_length += length_footer;
+            }
+            match_length += LZX_MIN_MATCH;
 
-	    /* get match offset */
-	    switch ((match_offset = (main_element >> 3))) {
-	    case 0: match_offset = R0;                             break;
-	    case 1: match_offset = R1; R1 = R0; R0 = match_offset; break;
-	    case 2: match_offset = R2; R2 = R0; R0 = match_offset; break;
-	    default:
-	      extra = extra_bits[match_offset];
-	      match_offset = position_base[match_offset] - 2;
-	      if (extra > 3) {
-		/* verbatim and aligned bits */
-		extra -= 3;
-		READ_BITS(verbatim_bits, extra);
-		match_offset += (verbatim_bits << 3);
-		READ_HUFFSYM(ALIGNED, aligned_bits);
-		match_offset += aligned_bits;
-	      }
-	      else if (extra == 3) {
-		/* aligned bits only */
-		READ_HUFFSYM(ALIGNED, aligned_bits);
-		match_offset += aligned_bits;
-	      }
-	      else if (extra > 0) { /* extra==1, extra==2 */
-		/* verbatim bits only */
-		READ_BITS(verbatim_bits, extra);
-		match_offset += verbatim_bits;
-	      }
-	      else /* extra == 0 */ {
-		/* ??? not defined in LZX specification! */
-		match_offset = 1;
-	      }
-	      /* update repeated offset LRU queue */
-	      R2 = R1; R1 = R0; R0 = match_offset;
-	    }
+            /* get match offset */
+            switch ((match_offset = (main_element >> 3))) {
+            case 0: match_offset = R0;                             break;
+            case 1: match_offset = R1; R1 = R0; R0 = match_offset; break;
+            case 2: match_offset = R2; R2 = R0; R0 = match_offset; break;
+            default:
+              extra = (match_offset >= 36) ? 17 : extra_bits[match_offset];
+              match_offset = position_base[match_offset] - 2;
+              if (extra > 3) {
+                /* verbatim and aligned bits */
+                extra -= 3;
+                READ_BITS(verbatim_bits, extra);
+                match_offset += (verbatim_bits << 3);
+                READ_HUFFSYM(ALIGNED, aligned_bits);
+                match_offset += aligned_bits;
+              }
+              else if (extra == 3) {
+                /* aligned bits only */
+                READ_HUFFSYM(ALIGNED, aligned_bits);
+                match_offset += aligned_bits;
+              }
+              else if (extra > 0) { /* extra==1, extra==2 */
+                /* verbatim bits only */
+                READ_BITS(verbatim_bits, extra);
+                match_offset += verbatim_bits;
+              }
+              else /* extra == 0 */ {
+                /* ??? not defined in LZX specification! */
+                match_offset = 1;
+              }
+              /* update repeated offset LRU queue */
+              R2 = R1; R1 = R0; R0 = match_offset;
+            }
 
-	    if ((window_posn + match_length) > lzx->window_size) {
-	      D(("match ran over window wrap"))
-	      return lzx->error = MSPACK_ERR_DECRUNCH;
-	    }
+            /* LZX DELTA uses max match length to signal even longer match */
+            if (match_length == LZX_MAX_MATCH && lzx->is_delta) {
+                int extra_len = 0;
+                ENSURE_BITS(3); /* 4 entry huffman tree */
+                if (PEEK_BITS(1) == 0) {
+                    REMOVE_BITS(1); /* '0' -> 8 extra length bits */
+                    READ_BITS(extra_len, 8);
+                }
+                else if (PEEK_BITS(2) == 2) {
+                    REMOVE_BITS(2); /* '10' -> 10 extra length bits + 0x100 */
+                    READ_BITS(extra_len, 10);
+                    extra_len += 0x100;
+                }
+                else if (PEEK_BITS(3) == 6) {
+                    REMOVE_BITS(3); /* '110' -> 12 extra length bits + 0x500 */
+                    READ_BITS(extra_len, 12);
+                    extra_len += 0x500;
+                }
+                else {
+                    REMOVE_BITS(3); /* '111' -> 15 extra length bits */
+                    READ_BITS(extra_len, 15);
+                }
+                match_length += extra_len;
+            }
 
-	    /* copy match */
-	    rundest = &window[window_posn];
-	    i = match_length;
-	    /* does match offset wrap the window? */
-	    if (match_offset > window_posn) {
-	      /* j = length from match offset to end of window */
-	      j = match_offset - window_posn;
-	      if (j > (int) lzx->window_size) {
-		D(("match offset beyond window boundaries"))
-		return lzx->error = MSPACK_ERR_DECRUNCH;
-	      }
-	      runsrc = &window[lzx->window_size - j];
-	      if (j < i) {
-		/* if match goes over the window edge, do two copy runs */
-		i -= j; while (j-- > 0) *rundest++ = *runsrc++;
-		runsrc = window;
-	      }
-	      while (i-- > 0) *rundest++ = *runsrc++;
-	    }
-	    else {
-	      runsrc = rundest - match_offset;
-	      while (i-- > 0) *rundest++ = *runsrc++;
-	    }
+            if ((window_posn + match_length) > lzx->window_size) {
+              D(("match ran over window wrap"))
+              return lzx->error = MSPACK_ERR_DECRUNCH;
+            }
 
-	    this_run    -= match_length;
-	    window_posn += match_length;
-	  }
-	} /* while (this_run > 0) */
-	break;
+            /* copy match */
+            rundest = &window[window_posn];
+            i = match_length;
+            /* does match offset wrap the window? */
+            if (match_offset > window_posn) {
+              if ((off_t)match_offset > lzx->offset &&
+                  (match_offset - window_posn) > lzx->ref_data_size)
+              {
+                D(("match offset beyond LZX stream"))
+                return lzx->error = MSPACK_ERR_DECRUNCH;
+              }
+              /* j = length from match offset to end of window */
+              j = match_offset - window_posn;
+              if (j > (int) lzx->window_size) {
+                D(("match offset beyond window boundaries"))
+                return lzx->error = MSPACK_ERR_DECRUNCH;
+              }
+              runsrc = &window[lzx->window_size - j];
+              if (j < i) {
+                /* if match goes over the window edge, do two copy runs */
+                i -= j; while (j-- > 0) *rundest++ = *runsrc++;
+                runsrc = window;
+              }
+              while (i-- > 0) *rundest++ = *runsrc++;
+            }
+            else {
+              runsrc = rundest - match_offset;
+              while (i-- > 0) *rundest++ = *runsrc++;
+            }
+
+            this_run    -= match_length;
+            window_posn += match_length;
+          }
+        } /* while (this_run > 0) */
+        break;
 
       case LZX_BLOCKTYPE_UNCOMPRESSED:
-	/* as this_run is limited not to wrap a frame, this also means it
-	 * won't wrap the window (as the window is a multiple of 32k) */
-	rundest = &window[window_posn];
-	window_posn += this_run;
-	while (this_run > 0) {
-	  if ((i = (int)(i_end - i_ptr))) {
-	    if (i > this_run) i = this_run;
-	    lzx->sys->copy(i_ptr, rundest, (size_t) i);
-	    rundest  += i;
-	    i_ptr    += i;
-	    this_run -= i;
-	  }
-	  else {
-	    if (lzxd_read_input(lzx)) return lzx->error;
-	    i_ptr = lzx->i_ptr;
-	    i_end = lzx->i_end;
-	  }
-	}
-	break;
+        /* as this_run is limited not to wrap a frame, this also means it
+         * won't wrap the window (as the window is a multiple of 32k) */
+        rundest = &window[window_posn];
+        window_posn += this_run;
+        while (this_run > 0) {
+          if ((i = (int)(i_end - i_ptr)) == 0) {
+            READ_IF_NEEDED;
+          }
+          else {
+            if (i > this_run) i = this_run;
+            lzx->sys->copy(i_ptr, rundest, (size_t) i);
+            rundest  += i;
+            i_ptr    += i;
+            this_run -= i;
+          }
+        }
+        break;
 
       default:
-	return lzx->error = MSPACK_ERR_DECRUNCH; /* might as well */
+        return lzx->error = MSPACK_ERR_DECRUNCH; /* might as well */
       }
 
       /* did the final match overrun our desired this_run length? */
       if (this_run < 0) {
-	if ((unsigned int)(-this_run) > lzx->block_remaining) {
-	  D(("overrun went past end of block by %d (%d remaining)",
-	     -this_run, lzx->block_remaining ))
-	  return lzx->error = MSPACK_ERR_DECRUNCH;
-	}
-	lzx->block_remaining -= -this_run;
+        if ((unsigned int)(-this_run) > lzx->block_remaining) {
+          D(("overrun went past end of block by %d (%d remaining)",
+             -this_run, lzx->block_remaining ))
+          return lzx->error = MSPACK_ERR_DECRUNCH;
+        }
+        lzx->block_remaining -= -this_run;
       }
     } /* while (bytes_todo > 0) */
 
     /* streams don't extend over frame boundaries */
     if ((window_posn - lzx->frame_posn) != frame_size) {
       D(("decode beyond output frame limits! %d != %d",
-	 window_posn - lzx->frame_posn, frame_size))
+         window_posn - lzx->frame_posn, frame_size))
       return lzx->error = MSPACK_ERR_DECRUNCH;
     }
 
@@ -818,13 +825,14 @@ int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
 
     /* check that we've used all of the previous frame first */
     if (lzx->o_ptr != lzx->o_end) {
-      D(("%d avail bytes, new %d frame", lzx->o_end-lzx->o_ptr, frame_size))
+      D(("%ld avail bytes, new %d frame",
+          (long)(lzx->o_end - lzx->o_ptr), frame_size))
       return lzx->error = MSPACK_ERR_DECRUNCH;
     }
 
     /* does this intel block _really_ need decoding? */
     if (lzx->intel_started && lzx->intel_filesize &&
-	(lzx->frame <= 32768) && (frame_size > 10))
+        (lzx->frame <= 32768) && (frame_size > 10))
     {
       unsigned char *data    = &lzx->e8_buf[0];
       unsigned char *dataend = &lzx->e8_buf[frame_size - 10];
@@ -837,17 +845,17 @@ int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
       lzx->sys->copy(&lzx->window[lzx->frame_posn], data, frame_size);
 
       while (data < dataend) {
-	if (*data++ != 0xE8) { curpos++; continue; }
-	abs_off = data[0] | (data[1]<<8) | (data[2]<<16) | (data[3]<<24);
-	if ((abs_off >= -curpos) && (abs_off < filesize)) {
-	  rel_off = (abs_off >= 0) ? abs_off - curpos : abs_off + filesize;
-	  data[0] = (unsigned char) rel_off;
-	  data[1] = (unsigned char) (rel_off >> 8);
-	  data[2] = (unsigned char) (rel_off >> 16);
-	  data[3] = (unsigned char) (rel_off >> 24);
-	}
-	data += 4;
-	curpos += 5;
+        if (*data++ != 0xE8) { curpos++; continue; }
+        abs_off = data[0] | (data[1]<<8) | (data[2]<<16) | (data[3]<<24);
+        if ((abs_off >= -curpos) && (abs_off < filesize)) {
+          rel_off = (abs_off >= 0) ? abs_off - curpos : abs_off + filesize;
+          data[0] = (unsigned char) rel_off;
+          data[1] = (unsigned char) (rel_off >> 8);
+          data[2] = (unsigned char) (rel_off >> 16);
+          data[3] = (unsigned char) (rel_off >> 24);
+        }
+        data += 4;
+        curpos += 5;
       }
       lzx->intel_curpos += frame_size;
     }
diff --git a/third_party/mspack/mspack.h b/third_party/mspack/mspack.h
index 0d2584dee..f9161f983 100644
--- a/third_party/mspack/mspack.h
+++ b/third_party/mspack/mspack.h
@@ -1,5 +1,5 @@
 /* libmspack -- a library for working with Microsoft compression formats.
- * (C) 2003-2004 Stuart Caie <kyzer@4u.net>
+ * (C) 2003-2016 Stuart Caie <kyzer@cabextract.org.uk>
  *
  * libmspack is free software; you can redistribute it and/or modify it under
  * the terms of the GNU Lesser General Public License (LGPL) version 2.1
@@ -21,6 +21,79 @@
  * libmspack is a library which provides compressors and decompressors,
  * archivers and dearchivers for Microsoft compression formats.
  *
+ * \section formats Formats supported
+ *
+ * The following file formats are supported:
+ * - SZDD files, which use LZSS compression
+ * - KWAJ files, which use LZSS, LZSS+Huffman or deflate compression
+ * - .HLP (MS Help) files, which use LZSS compression
+ * - .CAB (MS Cabinet) files, which use deflate, LZX or Quantum compression
+ * - .CHM (HTML Help) files, which use LZX compression
+ * - .LIT (MS EBook) files, which use LZX compression and DES encryption
+ * - .LZX (Exchange Offline Addressbook) files, which use LZX compression
+ *
+ * To determine the capabilities of the library, and the binary
+ * compatibility version of any particular compressor or decompressor, use
+ * the mspack_version() function. The UNIX library interface version is
+ * defined as the highest-versioned library component.
+ *
+ * \section starting Getting started
+ *
+ * The macro MSPACK_SYS_SELFTEST() should be used to ensure the library can
+ * be used. In particular, it checks if the caller is using 32-bit file I/O
+ * when the library is compiled for 64-bit file I/O and vice versa.
+ *
+ * If compiled normally, the library includes basic file I/O and memory
+ * management functionality using the standard C library. This can be
+ * customised and replaced entirely by creating a mspack_system structure.
+ *
+ * A compressor or decompressor for the required format must be
+ * instantiated before it can be used. Each construction function takes
+ * one parameter, which is either a pointer to a custom mspack_system
+ * structure, or NULL to use the default. The instantiation returned, if
+ * not NULL, contains function pointers (methods) to work with the given
+ * file format.
+ * 
+ * For compression:
+ * - mspack_create_cab_compressor() creates a mscab_compressor
+ * - mspack_create_chm_compressor() creates a mschm_compressor
+ * - mspack_create_lit_compressor() creates a mslit_compressor
+ * - mspack_create_hlp_compressor() creates a mshlp_compressor
+ * - mspack_create_szdd_compressor() creates a msszdd_compressor
+ * - mspack_create_kwaj_compressor() creates a mskwaj_compressor
+ * - mspack_create_oab_compressor() creates a msoab_compressor
+ *
+ * For decompression:
+ * - mspack_create_cab_decompressor() creates a mscab_decompressor
+ * - mspack_create_chm_decompressor() creates a mschm_decompressor
+ * - mspack_create_lit_decompressor() creates a mslit_decompressor
+ * - mspack_create_hlp_decompressor() creates a mshlp_decompressor
+ * - mspack_create_szdd_decompressor() creates a msszdd_decompressor
+ * - mspack_create_kwaj_decompressor() creates a mskwaj_decompressor
+ * - mspack_create_oab_decompressor() creates a msoab_decompressor
+ *
+ * Once finished working with a format, each kind of
+ * compressor/decompressor has its own specific destructor:
+ * - mspack_destroy_cab_compressor()
+ * - mspack_destroy_cab_decompressor()
+ * - mspack_destroy_chm_compressor()
+ * - mspack_destroy_chm_decompressor()
+ * - mspack_destroy_lit_compressor()
+ * - mspack_destroy_lit_decompressor()
+ * - mspack_destroy_hlp_compressor()
+ * - mspack_destroy_hlp_decompressor()
+ * - mspack_destroy_szdd_compressor()
+ * - mspack_destroy_szdd_decompressor()
+ * - mspack_destroy_kwaj_compressor()
+ * - mspack_destroy_kwaj_decompressor()
+ * - mspack_destroy_oab_compressor()
+ * - mspack_destroy_oab_decompressor()
+ *
+ * Destroying a compressor or decompressor does not destroy any objects,
+ * structures or handles that have been created using that compressor or
+ * decompressor. Ensure that everything created or opened is destroyed or
+ * closed before compressor/decompressor is itself destroyed.
+ *
  * \section errors Error codes
  *
  * All compressors and decompressors use the same set of error codes. Most
@@ -45,6 +118,41 @@
  * - #MSPACK_ERR_CHECKSUM indicates that a data checksum has failed.
  * - #MSPACK_ERR_CRUNCH indicates an error occured during compression.
  * - #MSPACK_ERR_DECRUNCH indicates an error occured during decompression.
+ *
+ * \section threading Multi-threading
+ *
+ * libmspack methods are reentrant and multithreading-safe when each
+ * thread has its own compressor or decompressor.
+
+ * You should not call multiple methods simultaneously on a single
+ * compressor or decompressor instance.
+ *
+ * If this may happen, you can either use one compressor or
+ * decompressor per thread, or you can use your preferred lock,
+ * semaphore or mutex library to ensure no more than one method on a
+ * compressor/decompressor is called simultaneously. libmspack will
+ * not do this locking for you.
+ *
+ * Example of incorrect behaviour:
+ * - thread 1 calls mspack_create_cab_decompressor()
+ * - thread 1 calls open()
+ * - thread 1 calls extract() for one file
+ * - thread 2 simultaneously calls extract() for another file
+ *
+ * Correct behaviour:
+ * - thread 1 calls mspack_create_cab_decompressor()
+ * - thread 2 calls mspack_create_cab_decompressor()
+ * - thread 1 calls its own open() / extract()
+ * - thread 2 simultaneously calls its own open() / extract()
+ *
+ * Also correct behaviour:
+ * - thread 1 calls mspack_create_cab_decompressor()
+ * - thread 1 locks a mutex for with the decompressor before
+ *   calling any methods on it, and unlocks the mutex after each
+ *   method returns.
+ * - thread 1 can share the results of open() with thread 2, and both
+ *   can call extract(), provided they both guard against simultaneous
+ *   use of extract(), and any other methods, with the mutex
  */
 
 #ifndef LIB_MSPACK_H
@@ -57,6 +165,102 @@ extern "C" {
 #include <sys/types.h>
 #include <stdlib.h>
 
+/**
+ * System self-test function, to ensure both library and calling program
+ * can use one another.
+ *
+ * A result of MSPACK_ERR_OK means the library and caller are
+ * compatible. Any other result indicates that the library and caller are
+ * not compatible and should not be used. In particular, a value of
+ * MSPACK_ERR_SEEK means the library and caller use different off_t
+ * datatypes.
+ *
+ * It should be used like so:
+ *
+ * @code
+ * int selftest_result;
+ * MSPACK_SYS_SELFTEST(selftest_result);
+ * if (selftest_result != MSPACK_ERR_OK) {
+ *   fprintf(stderr, "incompatible with this build of libmspack\n");
+ *   exit(0);
+ * }
+ * @endcode
+ *
+ * @param  result   an int variable to store the result of the self-test
+ */
+#define MSPACK_SYS_SELFTEST(result)  do { \
+  (result) = mspack_sys_selftest_internal(sizeof(off_t)); \
+} while (0)
+
+/** Part of the MSPACK_SYS_SELFTEST() macro, must not be used directly. */
+extern int mspack_sys_selftest_internal(int);
+
+/**
+ * Enquire about the binary compatibility version of a specific interface in
+ * the library. Currently, the following interfaces are defined:
+ *
+ * - #MSPACK_VER_LIBRARY: the overall library
+ * - #MSPACK_VER_SYSTEM: the mspack_system interface
+ * - #MSPACK_VER_MSCABD: the mscab_decompressor interface
+ * - #MSPACK_VER_MSCABC: the mscab_compressor interface
+ * - #MSPACK_VER_MSCHMD: the mschm_decompressor interface
+ * - #MSPACK_VER_MSCHMC: the mschm_compressor interface
+ * - #MSPACK_VER_MSLITD: the mslit_decompressor interface
+ * - #MSPACK_VER_MSLITC: the mslit_compressor interface
+ * - #MSPACK_VER_MSHLPD: the mshlp_decompressor interface
+ * - #MSPACK_VER_MSHLPC: the mshlp_compressor interface
+ * - #MSPACK_VER_MSSZDDD: the msszdd_decompressor interface
+ * - #MSPACK_VER_MSSZDDC: the msszdd_compressor interface
+ * - #MSPACK_VER_MSKWAJD: the mskwaj_decompressor interface
+ * - #MSPACK_VER_MSKWAJC: the mskwaj_compressor interface
+ * - #MSPACK_VER_MSOABD: the msoab_decompressor interface
+ * - #MSPACK_VER_MSOABC: the msoab_compressor interface
+ *
+ * The result of the function should be interpreted as follows:
+ * - -1: this interface is completely unknown to the library
+ * - 0: this interface is known, but non-functioning
+ * - 1: this interface has all basic functionality
+ * - 2, 3, ...: this interface has additional functionality, clearly marked
+ *   in the documentation as "version 2", "version 3" and so on.
+ *
+ * @param entity the interface to request current version of
+ * @return the version of the requested interface
+ */
+extern int mspack_version(int entity);
+
+/** Pass to mspack_version() to get the overall library version */
+#define MSPACK_VER_LIBRARY   (0)
+/** Pass to mspack_version() to get the mspack_system version */
+#define MSPACK_VER_SYSTEM    (1)
+/** Pass to mspack_version() to get the mscab_decompressor version */
+#define MSPACK_VER_MSCABD    (2)
+/** Pass to mspack_version() to get the mscab_compressor version */
+#define MSPACK_VER_MSCABC    (3)
+/** Pass to mspack_version() to get the mschm_decompressor version */
+#define MSPACK_VER_MSCHMD    (4)
+/** Pass to mspack_version() to get the mschm_compressor version */
+#define MSPACK_VER_MSCHMC    (5)
+/** Pass to mspack_version() to get the mslit_decompressor version */
+#define MSPACK_VER_MSLITD    (6)
+/** Pass to mspack_version() to get the mslit_compressor version */
+#define MSPACK_VER_MSLITC    (7)
+/** Pass to mspack_version() to get the mshlp_decompressor version */
+#define MSPACK_VER_MSHLPD    (8)
+/** Pass to mspack_version() to get the mshlp_compressor version */
+#define MSPACK_VER_MSHLPC    (9)
+/** Pass to mspack_version() to get the msszdd_decompressor version */
+#define MSPACK_VER_MSSZDDD   (10)
+/** Pass to mspack_version() to get the msszdd_compressor version */
+#define MSPACK_VER_MSSZDDC   (11)
+/** Pass to mspack_version() to get the mskwaj_decompressor version */
+#define MSPACK_VER_MSKWAJD   (12)
+/** Pass to mspack_version() to get the mskwaj_compressor version */
+#define MSPACK_VER_MSKWAJC   (13)
+/** Pass to mspack_version() to get the msoab_decompressor version */
+#define MSPACK_VER_MSOABD    (14)
+/** Pass to mspack_version() to get the msoab_compressor version */
+#define MSPACK_VER_MSOABC    (15)
+
 /* --- file I/O abstraction ------------------------------------------------ */
 
 /**
@@ -82,7 +286,7 @@ struct mspack_system {
   /**
    * Opens a file for reading, writing, appending or updating.
    *
-   * @param this     a self-referential pointer to the mspack_system
+   * @param self     a self-referential pointer to the mspack_system
    *                 structure whose open() method is being called. If
    *                 this pointer is required by close(), read(), write(),
    *                 seek() or tell(), it should be stored in the result
@@ -99,12 +303,13 @@ struct mspack_system {
    * @return a pointer to a mspack_file structure. This structure officially
    *         contains no members, its true contents are up to the
    *         mspack_system implementor. It should contain whatever is needed
-   *         for other mspack_system methods to operate.
+   *         for other mspack_system methods to operate. Returning the NULL
+   *         pointer indicates an error condition.
    * @see close(), read(), write(), seek(), tell(), message()
    */
-  struct mspack_file * (*open)(struct mspack_system *sys,
-			       char *filename,
-			       int mode);
+  struct mspack_file * (*open)(struct mspack_system *self,
+                               const char *filename,
+                               int mode);
 
   /**
    * Closes a previously opened file. If any memory was allocated for this
@@ -123,12 +328,14 @@ struct mspack_system {
    * @param bytes   the number of bytes to read from the file.
    * @return the number of bytes successfully read (this can be less than
    *         the number requested), zero to mark the end of file, or less
-   *         than zero to indicate an error.
+   *         than zero to indicate an error. The library does not "retry"
+   *         reads and assumes short reads are due to EOF, so you should
+   *         avoid returning short reads because of transient errors.
    * @see open(), write()
    */
   int (*read)(struct mspack_file *file,
-	      void *buffer,
-	      int bytes);
+              void *buffer,
+              int bytes);
 
   /**
    * Writes a given number of bytes to an open file.
@@ -144,8 +351,8 @@ struct mspack_system {
    * @see open(), read()
    */
   int (*write)(struct mspack_file *file,
-	       void *buffer,
-	       int bytes);
+               void *buffer,
+               int bytes);
 
   /**
    * Seeks to a specific file offset within an open file.
@@ -171,8 +378,8 @@ struct mspack_system {
    * @see open(), tell()
    */
   int (*seek)(struct mspack_file *file,
-	      off_t offset,
-	      int mode);
+              off_t offset,
+              int mode);
 
   /**
    * Returns the current file position (in bytes) of the given file.
@@ -198,26 +405,26 @@ struct mspack_system {
    * @see open()
    */
   void (*message)(struct mspack_file *file,
-		  char *format,
-		  ...);
+                  const char *format,
+                  ...);
 
   /**
    * Allocates memory.
    *
-   * @param sys      a self-referential pointer to the mspack_system
+   * @param self     a self-referential pointer to the mspack_system
    *                 structure whose alloc() method is being called.
    * @param bytes    the number of bytes to allocate
    * @result a pointer to the requested number of bytes, or NULL if
    *         not enough memory is available
    * @see free()
    */
-  void * (*alloc)(struct mspack_system *sys,
-		  size_t bytes);
+  void * (*alloc)(struct mspack_system *self,
+                  size_t bytes);
   
   /**
    * Frees memory.
    * 
-   * @param ptr the memory to be freed.
+   * @param ptr the memory to be freed. NULL is accepted and ignored.
    * @see alloc()
    */
   void (*free)(void *ptr);
@@ -235,8 +442,8 @@ struct mspack_system {
    * @param bytes the size of the memory region, in bytes
    */
   void (*copy)(void *src,
-	       void *dest,
-	       size_t bytes);
+               void *dest,
+               size_t bytes);
 
   /**
    * A null pointer to mark the end of mspack_system. It must equal NULL.
@@ -299,8 +506,1857 @@ struct mspack_file {
 /** Error code: error during decompression */
 #define MSPACK_ERR_DECRUNCH    (11)
 
-#ifdef __cplusplus
+/* --- functions available in library -------------------------------------- */
+
+/** Creates a new CAB compressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mscab_compressor or NULL
+ */
+extern struct mscab_compressor *
+  mspack_create_cab_compressor(struct mspack_system *sys);
+
+/** Creates a new CAB decompressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mscab_decompressor or NULL
+ */
+extern struct mscab_decompressor *
+  mspack_create_cab_decompressor(struct mspack_system *sys);
+
+/** Destroys an existing CAB compressor.
+ * @param self the #mscab_compressor to destroy
+ */
+extern void mspack_destroy_cab_compressor(struct mscab_compressor *self);
+
+/** Destroys an existing CAB decompressor.
+ * @param self the #mscab_decompressor to destroy
+ */
+extern void mspack_destroy_cab_decompressor(struct mscab_decompressor *self);
+
+
+/** Creates a new CHM compressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mschm_compressor or NULL
+ */
+extern struct mschm_compressor *
+  mspack_create_chm_compressor(struct mspack_system *sys);
+
+/** Creates a new CHM decompressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mschm_decompressor or NULL
+ */
+extern struct mschm_decompressor *
+  mspack_create_chm_decompressor(struct mspack_system *sys);
+
+/** Destroys an existing CHM compressor.
+ * @param self the #mschm_compressor to destroy
+ */
+extern void mspack_destroy_chm_compressor(struct mschm_compressor *self);
+
+/** Destroys an existing CHM decompressor.
+ * @param self the #mschm_decompressor to destroy
+ */
+extern void mspack_destroy_chm_decompressor(struct mschm_decompressor *self);
+
+
+/** Creates a new LIT compressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mslit_compressor or NULL
+ */
+extern struct mslit_compressor *
+  mspack_create_lit_compressor(struct mspack_system *sys);
+
+/** Creates a new LIT decompressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mslit_decompressor or NULL
+ */
+extern struct mslit_decompressor *
+  mspack_create_lit_decompressor(struct mspack_system *sys);
+
+/** Destroys an existing LIT compressor.
+ * @param self the #mslit_compressor to destroy
+ */
+extern void mspack_destroy_lit_compressor(struct mslit_compressor *self);
+
+/** Destroys an existing LIT decompressor.
+ * @param self the #mslit_decompressor to destroy
+ */
+extern void mspack_destroy_lit_decompressor(struct mslit_decompressor *self);
+
+
+/** Creates a new HLP compressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mshlp_compressor or NULL
+ */
+extern struct mshlp_compressor *
+  mspack_create_hlp_compressor(struct mspack_system *sys);
+
+/** Creates a new HLP decompressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mshlp_decompressor or NULL
+ */
+extern struct mshlp_decompressor *
+  mspack_create_hlp_decompressor(struct mspack_system *sys);
+
+/** Destroys an existing hlp compressor.
+ * @param self the #mshlp_compressor to destroy
+ */
+extern void mspack_destroy_hlp_compressor(struct mshlp_compressor *self);
+
+/** Destroys an existing hlp decompressor.
+ * @param self the #mshlp_decompressor to destroy
+ */
+extern void mspack_destroy_hlp_decompressor(struct mshlp_decompressor *self);
+
+
+/** Creates a new SZDD compressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #msszdd_compressor or NULL
+ */
+extern struct msszdd_compressor *
+  mspack_create_szdd_compressor(struct mspack_system *sys);
+
+/** Creates a new SZDD decompressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #msszdd_decompressor or NULL
+ */
+extern struct msszdd_decompressor *
+  mspack_create_szdd_decompressor(struct mspack_system *sys);
+
+/** Destroys an existing SZDD compressor.
+ * @param self the #msszdd_compressor to destroy
+ */
+extern void mspack_destroy_szdd_compressor(struct msszdd_compressor *self);
+
+/** Destroys an existing SZDD decompressor.
+ * @param self the #msszdd_decompressor to destroy
+ */
+extern void mspack_destroy_szdd_decompressor(struct msszdd_decompressor *self);
+
+
+/** Creates a new KWAJ compressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mskwaj_compressor or NULL
+ */
+extern struct mskwaj_compressor *
+  mspack_create_kwaj_compressor(struct mspack_system *sys);
+
+/** Creates a new KWAJ decompressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mskwaj_decompressor or NULL
+ */
+extern struct mskwaj_decompressor *
+  mspack_create_kwaj_decompressor(struct mspack_system *sys);
+
+/** Destroys an existing KWAJ compressor.
+ * @param self the #mskwaj_compressor to destroy
+ */
+extern void mspack_destroy_kwaj_compressor(struct mskwaj_compressor *self);
+
+/** Destroys an existing KWAJ decompressor.
+ * @param self the #mskwaj_decompressor to destroy
+ */
+extern void mspack_destroy_kwaj_decompressor(struct mskwaj_decompressor *self);
+
+
+/** Creates a new OAB compressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #msoab_compressor or NULL
+ */
+extern struct msoab_compressor *
+  mspack_create_oab_compressor(struct mspack_system *sys);
+
+/** Creates a new OAB decompressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #msoab_decompressor or NULL
+ */
+extern struct msoab_decompressor *
+  mspack_create_oab_decompressor(struct mspack_system *sys);
+
+/** Destroys an existing OAB compressor.
+ * @param self the #msoab_compressor to destroy
+ */
+extern void mspack_destroy_oab_compressor(struct msoab_compressor *self);
+
+/** Destroys an existing OAB decompressor.
+ * @param self the #msoab_decompressor to destroy
+ */
+extern void mspack_destroy_oab_decompressor(struct msoab_decompressor *self);
+
+
+/* --- support for .CAB (MS Cabinet) file format --------------------------- */
+
+/**
+ * A structure which represents a single cabinet file.
+ *
+ * All fields are READ ONLY.
+ *
+ * If this cabinet is part of a merged cabinet set, the #files and #folders
+ * fields are common to all cabinets in the set, and will be identical.
+ *
+ * @see mscab_decompressor::open(), mscab_decompressor::close(),
+ *      mscab_decompressor::search()
+ */
+struct mscabd_cabinet {
+  /**
+   * The next cabinet in a chained list, if this cabinet was opened with
+   * mscab_decompressor::search(). May be NULL to mark the end of the
+   * list.
+   */
+  struct mscabd_cabinet *next;
+
+  /**
+   * The filename of the cabinet. More correctly, the filename of the
+   * physical file that the cabinet resides in. This is given by the
+   * library user and may be in any format.
+   */
+  const char *filename;
+  
+  /** The file offset of cabinet within the physical file it resides in. */
+  off_t base_offset;
+
+  /** The length of the cabinet file in bytes. */
+  unsigned int length;
+
+  /** The previous cabinet in a cabinet set, or NULL. */
+  struct mscabd_cabinet *prevcab;
+
+  /** The next cabinet in a cabinet set, or NULL. */
+  struct mscabd_cabinet *nextcab;
+
+  /** The filename of the previous cabinet in a cabinet set, or NULL. */
+  char *prevname;
+
+  /** The filename of the next cabinet in a cabinet set, or NULL. */
+  char *nextname;
+
+  /** The name of the disk containing the previous cabinet in a cabinet
+   * set, or NULL.
+   */
+  char *previnfo;
+
+  /** The name of the disk containing the next cabinet in a cabinet set,
+   * or NULL.
+   */
+  char *nextinfo;
+
+  /** A list of all files in the cabinet or cabinet set. */
+  struct mscabd_file *files;
+
+  /** A list of all folders in the cabinet or cabinet set. */
+  struct mscabd_folder *folders;
+
+  /** 
+   * The set ID of the cabinet. All cabinets in the same set should have
+   * the same set ID.
+   */
+  unsigned short set_id;
+
+  /**
+   * The index number of the cabinet within the set. Numbering should
+   * start from 0 for the first cabinet in the set, and increment by 1 for
+   * each following cabinet.
+   */
+  unsigned short set_index;
+
+  /**
+   * The number of bytes reserved in the header area of the cabinet.
+   *
+   * If this is non-zero and flags has MSCAB_HDR_RESV set, this data can
+   * be read by the calling application. It is of the given length,
+   * located at offset (base_offset + MSCAB_HDR_RESV_OFFSET) in the
+   * cabinet file.
+   *
+   * @see flags
+   */
+  unsigned short header_resv;
+
+  /**
+   * Header flags.
+   *
+   * - MSCAB_HDR_PREVCAB indicates the cabinet is part of a cabinet set, and
+   *                     has a predecessor cabinet.
+   * - MSCAB_HDR_NEXTCAB indicates the cabinet is part of a cabinet set, and
+   *                     has a successor cabinet.
+   * - MSCAB_HDR_RESV indicates the cabinet has reserved header space.
+   *
+   * @see prevname, previnfo, nextname, nextinfo, header_resv
+   */
+  int flags;
 };
+
+/** Offset from start of cabinet to the reserved header data (if present). */
+#define MSCAB_HDR_RESV_OFFSET (0x28)
+
+/** Cabinet header flag: cabinet has a predecessor */
+#define MSCAB_HDR_PREVCAB (0x01)
+/** Cabinet header flag: cabinet has a successor */
+#define MSCAB_HDR_NEXTCAB (0x02)
+/** Cabinet header flag: cabinet has reserved header space */
+#define MSCAB_HDR_RESV    (0x04)
+
+/**
+ * A structure which represents a single folder in a cabinet or cabinet set.
+ *
+ * All fields are READ ONLY.
+ *
+ * A folder is a single compressed stream of data. When uncompressed, it
+ * holds the data of one or more files. A folder may be split across more
+ * than one cabinet.
+ */
+struct mscabd_folder {
+  /**
+   * A pointer to the next folder in this cabinet or cabinet set, or NULL
+   * if this is the final folder.
+   */
+  struct mscabd_folder *next;
+
+  /** 
+   * The compression format used by this folder.
+   *
+   * The macro MSCABD_COMP_METHOD() should be used on this field to get
+   * the algorithm used. The macro MSCABD_COMP_LEVEL() should be used to get
+   * the "compression level".
+   *
+   * @see MSCABD_COMP_METHOD(), MSCABD_COMP_LEVEL()
+   */
+  int comp_type;
+
+  /**
+   * The total number of data blocks used by this folder. This includes
+   * data blocks present in other files, if this folder spans more than
+   * one cabinet.
+   */
+  unsigned int num_blocks;
+};
+
+/**
+ * Returns the compression method used by a folder.
+ *
+ * @param comp_type a mscabd_folder::comp_type value
+ * @return one of #MSCAB_COMP_NONE, #MSCAB_COMP_MSZIP, #MSCAB_COMP_QUANTUM
+ *         or #MSCAB_COMP_LZX
+ */
+#define MSCABD_COMP_METHOD(comp_type) ((comp_type) & 0x0F)
+/**
+ * Returns the compression level used by a folder.
+ *
+ * @param comp_type a mscabd_folder::comp_type value
+ * @return the compression level. This is only defined by LZX and Quantum
+ *         compression
+ */
+#define MSCABD_COMP_LEVEL(comp_type) (((comp_type) >> 8) & 0x1F)
+
+/** Compression mode: no compression. */
+#define MSCAB_COMP_NONE       (0)
+/** Compression mode: MSZIP (deflate) compression. */
+#define MSCAB_COMP_MSZIP      (1)
+/** Compression mode: Quantum compression */
+#define MSCAB_COMP_QUANTUM    (2)
+/** Compression mode: LZX compression */
+#define MSCAB_COMP_LZX        (3)
+
+/**
+ * A structure which represents a single file in a cabinet or cabinet set.
+ *
+ * All fields are READ ONLY.
+ */
+struct mscabd_file {
+  /**
+   * The next file in the cabinet or cabinet set, or NULL if this is the
+   * final file.
+   */
+  struct mscabd_file *next;
+
+  /**
+   * The filename of the file.
+   *
+   * A null terminated string of up to 255 bytes in length, it may be in
+   * either ISO-8859-1 or UTF8 format, depending on the file attributes.
+   *
+   * @see attribs
+   */
+  char *filename;
+
+  /** The uncompressed length of the file, in bytes. */
+  unsigned int length;
+
+  /**
+   * File attributes.
+   *
+   * The following attributes are defined:
+   * - #MSCAB_ATTRIB_RDONLY indicates the file is write protected.
+   * - #MSCAB_ATTRIB_HIDDEN indicates the file is hidden.
+   * - #MSCAB_ATTRIB_SYSTEM indicates the file is a operating system file.
+   * - #MSCAB_ATTRIB_ARCH indicates the file is "archived".
+   * - #MSCAB_ATTRIB_EXEC indicates the file is an executable program.
+   * - #MSCAB_ATTRIB_UTF_NAME indicates the filename is in UTF8 format rather
+   *   than ISO-8859-1.
+   */
+  int attribs;
+
+  /** File's last modified time, hour field. */
+  char time_h;
+  /** File's last modified time, minute field. */
+  char time_m;
+  /** File's last modified time, second field. */
+  char time_s;
+
+  /** File's last modified date, day field. */
+  char date_d;
+  /** File's last modified date, month field. */
+  char date_m;
+  /** File's last modified date, year field. */
+  int date_y;
+
+  /** A pointer to the folder that contains this file. */
+  struct mscabd_folder *folder;
+
+  /** The uncompressed offset of this file in its folder. */
+  unsigned int offset;
+};
+
+/** mscabd_file::attribs attribute: file is read-only. */
+#define MSCAB_ATTRIB_RDONLY   (0x01)
+/** mscabd_file::attribs attribute: file is hidden. */
+#define MSCAB_ATTRIB_HIDDEN   (0x02)
+/** mscabd_file::attribs attribute: file is an operating system file. */
+#define MSCAB_ATTRIB_SYSTEM   (0x04)
+/** mscabd_file::attribs attribute: file is "archived". */
+#define MSCAB_ATTRIB_ARCH     (0x20)
+/** mscabd_file::attribs attribute: file is an executable program. */
+#define MSCAB_ATTRIB_EXEC     (0x40)
+/** mscabd_file::attribs attribute: filename is UTF8, not ISO-8859-1. */
+#define MSCAB_ATTRIB_UTF_NAME (0x80)
+
+/** mscab_decompressor::set_param() parameter: search buffer size. */
+#define MSCABD_PARAM_SEARCHBUF (0)
+/** mscab_decompressor::set_param() parameter: repair MS-ZIP streams? */
+#define MSCABD_PARAM_FIXMSZIP  (1)
+/** mscab_decompressor::set_param() parameter: size of decompression buffer */
+#define MSCABD_PARAM_DECOMPBUF (2)
+/** mscab_decompressor::set_param() parameter: salvage data from bad cabinets?
+ * If enabled, open() will skip file with bad folder indices or filenames
+ * rather than reject the whole cabinet, and extract() will limit rather than
+ * reject files with invalid offsets and lengths, and bad data block checksums
+ * will be ignored. Available only in CAB decoder version 2 and above.
+ */
+#define MSCABD_PARAM_SALVAGE   (3)
+
+/** TODO */
+struct mscab_compressor {
+  int dummy; 
+};
+
+/**
+ * A decompressor for .CAB (Microsoft Cabinet) files
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_cab_decompressor(), mspack_destroy_cab_decompressor()
+ */
+struct mscab_decompressor {
+  /**
+   * Opens a cabinet file and reads its contents.
+   *
+   * If the file opened is a valid cabinet file, all headers will be read
+   * and a mscabd_cabinet structure will be returned, with a full list of
+   * folders and files.
+   *
+   * In the case of an error occuring, NULL is returned and the error code
+   * is available from last_error().
+   *
+   * The filename pointer should be considered "in use" until close() is
+   * called on the cabinet.
+   *
+   * @param  self     a self-referential pointer to the mscab_decompressor
+   *                  instance being called
+   * @param  filename the filename of the cabinet file. This is passed
+   *                  directly to mspack_system::open().
+   * @return a pointer to a mscabd_cabinet structure, or NULL on failure
+   * @see close(), search(), last_error()
+   */
+  struct mscabd_cabinet * (*open) (struct mscab_decompressor *self,
+                                   const char *filename);
+
+  /**
+   * Closes a previously opened cabinet or cabinet set.
+   *
+   * This closes a cabinet, all cabinets associated with it via the
+   * mscabd_cabinet::next, mscabd_cabinet::prevcab and
+   * mscabd_cabinet::nextcab pointers, and all folders and files. All
+   * memory used by these entities is freed.
+   *
+   * The cabinet pointer is now invalid and cannot be used again. All
+   * mscabd_folder and mscabd_file pointers from that cabinet or cabinet
+   * set are also now invalid, and cannot be used again.
+   *
+   * If the cabinet pointer given was created using search(), it MUST be
+   * the cabinet pointer returned by search() and not one of the later
+   * cabinet pointers further along the mscabd_cabinet::next chain.
+
+   * If extra cabinets have been added using append() or prepend(), these
+   * will all be freed, even if the cabinet pointer given is not the first
+   * cabinet in the set. Do NOT close() more than one cabinet in the set.
+   *
+   * The mscabd_cabinet::filename is not freed by the library, as it is
+   * not allocated by the library. The caller should free this itself if
+   * necessary, before it is lost forever.
+   *
+   * @param  self     a self-referential pointer to the mscab_decompressor
+   *                  instance being called
+   * @param  cab      the cabinet to close
+   * @see open(), search(), append(), prepend()
+   */
+  void (*close)(struct mscab_decompressor *self,
+                struct mscabd_cabinet *cab);
+
+  /**
+   * Searches a regular file for embedded cabinets.
+   *
+   * This opens a normal file with the given filename and will search the
+   * entire file for embedded cabinet files
+   *
+   * If any cabinets are found, the equivalent of open() is called on each
+   * potential cabinet file at the offset it was found. All successfully
+   * open()ed cabinets are kept in a list.
+   *
+   * The first cabinet found will be returned directly as the result of
+   * this method. Any further cabinets found will be chained in a list
+   * using the mscabd_cabinet::next field.
+   *
+   * In the case of an error occuring anywhere other than the simulated
+   * open(), NULL is returned and the error code is available from
+   * last_error().
+   *
+   * If no error occurs, but no cabinets can be found in the file, NULL is
+   * returned and last_error() returns MSPACK_ERR_OK.
+   *
+   * The filename pointer should be considered in use until close() is
+   * called on the cabinet.
+   *
+   * close() should only be called on the result of search(), not on any
+   * subsequent cabinets in the mscabd_cabinet::next chain.
+   *
+   * @param  self     a self-referential pointer to the mscab_decompressor
+   *                  instance being called
+   * @param  filename the filename of the file to search for cabinets. This
+   *                  is passed directly to mspack_system::open().
+   * @return a pointer to a mscabd_cabinet structure, or NULL
+   * @see close(), open(), last_error()
+   */
+  struct mscabd_cabinet * (*search) (struct mscab_decompressor *self,
+                                     const char *filename);
+
+  /**
+   * Appends one mscabd_cabinet to another, forming or extending a cabinet
+   * set.
+   *
+   * This will attempt to append one cabinet to another such that
+   * <tt>(cab->nextcab == nextcab) && (nextcab->prevcab == cab)</tt> and
+   * any folders split between the two cabinets are merged.
+   *
+   * The cabinets MUST be part of a cabinet set -- a cabinet set is a
+   * cabinet that spans more than one physical cabinet file on disk -- and
+   * must be appropriately matched.
+   *
+   * It can be determined if a cabinet has further parts to load by
+   * examining the mscabd_cabinet::flags field:
+   *
+   * - if <tt>(flags & MSCAB_HDR_PREVCAB)</tt> is non-zero, there is a
+   *   predecessor cabinet to open() and prepend(). Its MS-DOS
+   *   case-insensitive filename is mscabd_cabinet::prevname
+   * - if <tt>(flags & MSCAB_HDR_NEXTCAB)</tt> is non-zero, there is a
+   *   successor cabinet to open() and append(). Its MS-DOS case-insensitive
+   *   filename is mscabd_cabinet::nextname
+   *
+   * If the cabinets do not match, an error code will be returned. Neither
+   * cabinet has been altered, and both should be closed seperately.
+   *
+   * Files and folders in a cabinet set are a single entity. All cabinets
+   * in a set use the same file list, which is updated as cabinets in the
+   * set are added. All pointers to mscabd_folder and mscabd_file
+   * structures in either cabinet must be discarded and re-obtained after
+   * merging.
+   *
+   * @param  self     a self-referential pointer to the mscab_decompressor
+   *                  instance being called
+   * @param  cab      the cabinet which will be appended to,
+   *                  predecessor of nextcab
+   * @param  nextcab  the cabinet which will be appended,
+   *                  successor of cab
+   * @return an error code, or MSPACK_ERR_OK if successful
+   * @see prepend(), open(), close()
+   */
+  int (*append) (struct mscab_decompressor *self,
+                 struct mscabd_cabinet *cab,
+                 struct mscabd_cabinet *nextcab);
+
+  /**
+   * Prepends one mscabd_cabinet to another, forming or extending a
+   * cabinet set.
+   *
+   * This will attempt to prepend one cabinet to another, such that
+   * <tt>(cab->prevcab == prevcab) && (prevcab->nextcab == cab)</tt>. In
+   * all other respects, it is identical to append(). See append() for the
+   * full documentation.
+   *
+   * @param  self     a self-referential pointer to the mscab_decompressor
+   *                  instance being called
+   * @param  cab      the cabinet which will be prepended to,
+   *                  successor of prevcab
+   * @param  prevcab  the cabinet which will be prepended,
+   *                  predecessor of cab
+   * @return an error code, or MSPACK_ERR_OK if successful
+   * @see append(), open(), close()
+   */
+  int (*prepend) (struct mscab_decompressor *self,
+                  struct mscabd_cabinet *cab,
+                  struct mscabd_cabinet *prevcab);
+
+  /**
+   * Extracts a file from a cabinet or cabinet set.
+   *
+   * This extracts a compressed file in a cabinet and writes it to the given
+   * filename.
+   *
+   * The MS-DOS filename of the file, mscabd_file::filename, is NOT USED
+   * by extract(). The caller must examine this MS-DOS filename, copy and
+   * change it as necessary, create directories as necessary, and provide
+   * the correct filename as a parameter, which will be passed unchanged
+   * to the decompressor's mspack_system::open()
+   *
+   * If the file belongs to a split folder in a multi-part cabinet set,
+   * and not enough parts of the cabinet set have been loaded and appended
+   * or prepended, an error will be returned immediately.
+   *
+   * @param  self     a self-referential pointer to the mscab_decompressor
+   *                  instance being called
+   * @param  file     the file to be decompressed
+   * @param  filename the filename of the file being written to
+   * @return an error code, or MSPACK_ERR_OK if successful
+   */
+  int (*extract)(struct mscab_decompressor *self,
+                 struct mscabd_file *file,
+                 const char *filename);
+
+  /**
+   * Sets a CAB decompression engine parameter.
+   *
+   * The following parameters are defined:
+   * - #MSCABD_PARAM_SEARCHBUF: How many bytes should be allocated as a
+   *   buffer when using search()? The minimum value is 4.  The default
+   *   value is 32768.
+   * - #MSCABD_PARAM_FIXMSZIP: If non-zero, extract() will ignore bad
+   *   checksums and recover from decompression errors in MS-ZIP
+   *   compressed folders. The default value is 0 (don't recover).
+   * - #MSCABD_PARAM_DECOMPBUF: How many bytes should be used as an input
+   *   bit buffer by decompressors? The minimum value is 4. The default
+   *   value is 4096.
+   *
+   * @param  self     a self-referential pointer to the mscab_decompressor
+   *                  instance being called
+   * @param  param    the parameter to set
+   * @param  value    the value to set the parameter to
+   * @return MSPACK_ERR_OK if all is OK, or MSPACK_ERR_ARGS if there
+   *         is a problem with either parameter or value.
+   * @see search(), extract()
+   */
+  int (*set_param)(struct mscab_decompressor *self,
+                   int param,
+                   int value);
+
+  /**
+   * Returns the error code set by the most recently called method.
+   *
+   * This is useful for open() and search(), which do not return an error
+   * code directly.
+   *
+   * @param  self     a self-referential pointer to the mscab_decompressor
+   *                  instance being called
+   * @return the most recent error code
+   * @see open(), search()
+   */
+  int (*last_error)(struct mscab_decompressor *self);
+};
+
+/* --- support for .CHM (HTMLHelp) file format ----------------------------- */
+
+/**
+ * A structure which represents a file to be placed in a CHM helpfile.
+ *
+ * A contiguous array of these structures should be passed to
+ * mschm_compressor::generate(). The array list is terminated with an
+ * entry whose mschmc_file::section field is set to #MSCHMC_ENDLIST, the
+ * other fields in this entry are ignored.
+ */
+struct mschmc_file {
+  /** One of #MSCHMC_ENDLIST, #MSCHMC_UNCOMP or #MSCHMC_MSCOMP. */
+  int section;
+
+  /** The filename of the source file that will be added to the CHM. This
+   * is passed directly to mspack_system::open(). */
+  const char *filename;
+
+  /** The full path and filename of the file within the CHM helpfile, a
+   * UTF-1 encoded null-terminated string. */
+  char *chm_filename;
+
+  /** The length of the file, in bytes. This will be adhered to strictly
+   * and a read error will be issued if this many bytes cannot be read
+   * from the real file at CHM generation time. */
+  off_t length;
+};
+
+/**
+ * A structure which represents a section of a CHM helpfile.
+ *
+ * All fields are READ ONLY.
+ *
+ * Not used directly, but used as a generic base type for
+ * mschmd_sec_uncompressed and mschmd_sec_mscompressed.
+ */
+struct mschmd_section {
+  /** A pointer to the CHM helpfile that contains this section. */
+  struct mschmd_header *chm;
+
+  /**
+   * The section ID. Either 0 for the uncompressed section
+   * mschmd_sec_uncompressed, or 1 for the LZX compressed section
+   * mschmd_sec_mscompressed. No other section IDs are known.
+   */
+  unsigned int id;
+};
+
+/**
+ * A structure which represents the uncompressed section of a CHM helpfile.
+ * 
+ * All fields are READ ONLY.
+ */
+struct mschmd_sec_uncompressed {
+  /** Generic section data. */
+  struct mschmd_section base;
+
+  /** The file offset of where this section begins in the CHM helpfile. */
+  off_t offset;
+};
+
+/**
+ * A structure which represents the LZX compressed section of a CHM helpfile. 
+ * 
+ * All fields are READ ONLY.
+ */
+struct mschmd_sec_mscompressed {
+  /** Generic section data. */
+  struct mschmd_section base;
+
+  /** A pointer to the meta-file which represents all LZX compressed data. */
+  struct mschmd_file *content;
+
+  /** A pointer to the file which contains the LZX control data. */
+  struct mschmd_file *control;
+
+  /** A pointer to the file which contains the LZX reset table. */
+  struct mschmd_file *rtable;
+
+  /** A pointer to the file which contains the LZX span information.
+   * Available only in CHM decoder version 2 and above.
+   */
+  struct mschmd_file *spaninfo;
+};
+
+/**
+ * A structure which represents a CHM helpfile.
+ * 
+ * All fields are READ ONLY.
+ */
+struct mschmd_header {
+  /** The version of the CHM file format used in this file. */
+  unsigned int version;
+
+  /**
+   * The "timestamp" of the CHM helpfile. 
+   *
+   * It is the lower 32 bits of a 64-bit value representing the number of
+   * centiseconds since 1601-01-01 00:00:00 UTC, plus 42. It is not useful
+   * as a timestamp, but it is useful as a semi-unique ID.
+   */
+  unsigned int timestamp;
+      
+  /**
+   * The default Language and Country ID (LCID) of the user who ran the
+   * HTMLHelp Compiler. This is not the language of the CHM file itself.
+   */
+  unsigned int language;
+
+  /**
+   * The filename of the CHM helpfile. This is given by the library user
+   * and may be in any format.
+   */
+  const char *filename;
+
+  /** The length of the CHM helpfile, in bytes. */
+  off_t length;
+
+  /** A list of all non-system files in the CHM helpfile. */
+  struct mschmd_file *files;
+
+  /**
+   * A list of all system files in the CHM helpfile.
+   *
+   * System files are files which begin with "::". They are meta-files
+   * generated by the CHM creation process.
+   */
+  struct mschmd_file *sysfiles;
+
+  /** The section 0 (uncompressed) data in this CHM helpfile. */
+  struct mschmd_sec_uncompressed sec0;
+
+  /** The section 1 (MSCompressed) data in this CHM helpfile. */
+  struct mschmd_sec_mscompressed sec1;
+
+  /** The file offset of the first PMGL/PMGI directory chunk. */
+  off_t dir_offset;
+
+  /** The number of PMGL/PMGI directory chunks in this CHM helpfile. */
+  unsigned int num_chunks;
+
+  /** The size of each PMGL/PMGI chunk, in bytes. */
+  unsigned int chunk_size;
+
+  /** The "density" of the quick-reference section in PMGL/PMGI chunks. */
+  unsigned int density;
+
+  /** The depth of the index tree.
+   *
+   * - if 1, there are no PMGI chunks, only PMGL chunks.
+   * - if 2, there is 1 PMGI chunk. All chunk indices point to PMGL chunks.
+   * - if 3, the root PMGI chunk points to secondary PMGI chunks, which in
+   *         turn point to PMGL chunks.
+   * - and so on...
+   */
+  unsigned int depth;
+
+  /**
+   * The number of the root PMGI chunk.
+   *
+   * If there is no index in the CHM helpfile, this will be 0xFFFFFFFF.
+   */
+  unsigned int index_root;
+
+  /**
+   * The number of the first PMGL chunk. Usually zero.
+   * Available only in CHM decoder version 2 and above.
+   */
+  unsigned int first_pmgl;
+
+  /**
+   * The number of the last PMGL chunk. Usually num_chunks-1.
+   * Available only in CHM decoder version 2 and above.
+   */
+  unsigned int last_pmgl;
+
+  /**
+   * A cache of loaded chunks, filled in by mschm_decoder::fast_find().
+   * Available only in CHM decoder version 2 and above.
+   */
+  unsigned char **chunk_cache;
+};
+
+/**
+ * A structure which represents a file stored in a CHM helpfile.
+ * 
+ * All fields are READ ONLY.
+ */
+struct mschmd_file {
+  /**
+   * A pointer to the next file in the list, or NULL if this is the final
+   * file.
+   */
+  struct mschmd_file *next;
+
+  /**
+   * A pointer to the section that this file is located in. Indirectly,
+   * it also points to the CHM helpfile the file is located in.
+   */
+  struct mschmd_section *section;
+
+  /** The offset within the section data that this file is located at. */
+  off_t offset;
+
+  /** The length of this file, in bytes */
+  off_t length;
+
+  /** The filename of this file -- a null terminated string in UTF-8. */
+  char *filename;
+};
+
+/** mschmc_file::section value: end of CHM file list */
+#define MSCHMC_ENDLIST   (0)
+/** mschmc_file::section value: this file is in the Uncompressed section */
+#define MSCHMC_UNCOMP    (1)
+/** mschmc_file::section value: this file is in the MSCompressed section */
+#define MSCHMC_MSCOMP    (2)
+ 
+/** mschm_compressor::set_param() parameter: "timestamp" header */
+#define MSCHMC_PARAM_TIMESTAMP  (0)
+/** mschm_compressor::set_param() parameter: "language" header */
+#define MSCHMC_PARAM_LANGUAGE   (1)
+/** mschm_compressor::set_param() parameter: LZX window size */
+#define MSCHMC_PARAM_LZXWINDOW  (2)
+/** mschm_compressor::set_param() parameter: intra-chunk quickref density */
+#define MSCHMC_PARAM_DENSITY    (3)
+/** mschm_compressor::set_param() parameter: whether to create indices */
+#define MSCHMC_PARAM_INDEX      (4)
+
+/**
+ * A compressor for .CHM (Microsoft HTMLHelp) files.
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_chm_compressor(), mspack_destroy_chm_compressor()
+ */
+struct mschm_compressor {
+  /**
+   * Generates a CHM help file.
+   *
+   * The help file will contain up to two sections, an Uncompressed
+   * section and potentially an MSCompressed (LZX compressed)
+   * section.
+   *
+   * While the contents listing of a CHM file is always in lexical order,
+   * the file list passed in will be taken as the correct order for files
+   * within the sections.  It is in your interest to place similar files
+   * together for better compression.
+   *
+   * There are two modes of generation, to use a temporary file or not to
+   * use one. See use_temporary_file() for the behaviour of generate() in
+   * these two different modes.
+   *
+   * @param  self        a self-referential pointer to the mschm_compressor
+   *                     instance being called
+   * @param  file_list   an array of mschmc_file structures, terminated
+   *                     with an entry whose mschmc_file::section field is
+   *                     #MSCHMC_ENDLIST. The order of the list is
+   *                     preserved within each section. The length of any
+   *                     mschmc_file::chm_filename string cannot exceed
+   *                     roughly 4096 bytes. Each source file must be able
+   *                     to supply as many bytes as given in the
+   *                     mschmc_file::length field.
+   * @param  output_file the file to write the generated CHM helpfile to.
+   *                     This is passed directly to mspack_system::open()
+   * @return an error code, or MSPACK_ERR_OK if successful
+   * @see use_temporary_file() set_param()
+   */
+  int (*generate)(struct mschm_compressor *self,
+                  struct mschmc_file file_list[],
+                  const char *output_file);
+
+  /**
+   * Specifies whether a temporary file is used during CHM generation.
+   *
+   * The CHM file format includes data about the compressed section (such
+   * as its overall size) that is stored in the output CHM file prior to
+   * the compressed section itself. This unavoidably requires that the
+   * compressed section has to be generated, before these details can be
+   * set. There are several ways this can be handled. Firstly, the
+   * compressed section could be generated entirely in memory before
+   * writing any of the output CHM file. This approach is not used in
+   * libmspack, as the compressed section can exceed the addressable
+   * memory space on most architectures.
+   *
+   * libmspack has two options, either to write these unknowable sections
+   * with blank data, generate the compressed section, then re-open the
+   * output file for update once the compressed section has been
+   * completed, or to write the compressed section to a temporary file,
+   * then write the entire output file at once, performing a simple
+   * file-to-file copy for the compressed section.
+   *
+   * The simple solution of buffering the entire compressed section in
+   * memory can still be used, if desired. As the temporary file's
+   * filename is passed directly to mspack_system::open(), it is possible
+   * for a custom mspack_system implementation to hold this file in memory,
+   * without writing to a disk.
+   *
+   * If a temporary file is set, generate() performs the following
+   * sequence of events: the temporary file is opened for writing, the
+   * compression algorithm writes to the temporary file, the temporary
+   * file is closed.  Then the output file is opened for writing and the
+   * temporary file is re-opened for reading. The output file is written
+   * and the temporary file is read from. Both files are then closed. The
+   * temporary file itself is not deleted. If that is desired, the
+   * temporary file should be deleted after the completion of generate(),
+   * if it exists.
+   *
+   * If a temporary file is set not to be used, generate() performs the
+   * following sequence of events: the output file is opened for writing,
+   * then it is written and closed. The output file is then re-opened for
+   * update, the appropriate sections are seek()ed to and re-written, then
+   * the output file is closed.
+   *
+   * @param  self          a self-referential pointer to the
+   *                       mschm_compressor instance being called
+   * @param  use_temp_file non-zero if the temporary file should be used,
+   *                       zero if the temporary file should not be used.
+   * @param  temp_file     a file to temporarily write compressed data to,
+   *                       before opening it for reading and copying the
+   *                       contents to the output file. This is passed
+   *                       directly to mspack_system::open().
+   * @return an error code, or MSPACK_ERR_OK if successful
+   * @see generate()
+   */
+  int (*use_temporary_file)(struct mschm_compressor *self,
+                            int use_temp_file,
+                            const char *temp_file);
+  /**
+   * Sets a CHM compression engine parameter.
+   *
+   * The following parameters are defined:
+
+   * - #MSCHMC_PARAM_TIMESTAMP: Sets the "timestamp" of the CHM file
+   *   generated. This is not a timestamp, see mschmd_header::timestamp
+   *   for a description. If this timestamp is 0, generate() will use its
+   *   own algorithm for making a unique ID, based on the lengths and
+   *   names of files in the CHM itself. Defaults to 0, any value between
+   *   0 and (2^32)-1 is valid.
+   * - #MSCHMC_PARAM_LANGUAGE: Sets the "language" of the CHM file
+   *   generated.  This is not the language used in the CHM file, but the
+   *   language setting of the user who ran the HTMLHelp compiler. It
+   *   defaults to 0x0409. The valid range is between 0x0000 and 0x7F7F.
+   * - #MSCHMC_PARAM_LZXWINDOW: Sets the size of the LZX history window,
+   *   which is also the interval at which the compressed data stream can be
+   *   randomly accessed. The value is not a size in bytes, but a power of
+   *   two. The default value is 16 (which makes the window 2^16 bytes, or
+   *   64 kilobytes), the valid range is from 15 (32 kilobytes) to 21 (2
+   *   megabytes).
+   * - #MSCHMC_PARAM_DENSITY: Sets the "density" of quick reference
+   *   entries stored at the end of directory listing chunk. Each chunk is
+   *   4096 bytes in size, and contains as many file entries as there is
+   *   room for. At the other end of the chunk, a list of "quick reference"
+   *   pointers is included. The offset of every 'N'th file entry is given a
+   *   quick reference, where N = (2^density) + 1. The default density is
+   *   2. The smallest density is 0 (N=2), the maximum is 10 (N=1025). As
+   *   each file entry requires at least 5 bytes, the maximum number of
+   *   entries in a single chunk is roughly 800, so the maximum value 10
+   *   can be used to indicate there are no quickrefs at all.
+   * - #MSCHMC_PARAM_INDEX: Sets whether or not to include quick lookup
+   *   index chunk(s), in addition to normal directory listing chunks. A
+   *   value of zero means no index chunks will be created, a non-zero value
+   *   means index chunks will be created. The default is zero, "don't
+   *   create an index".
+   *
+   * @param  self     a self-referential pointer to the mschm_compressor
+   *                  instance being called
+   * @param  param    the parameter to set
+   * @param  value    the value to set the parameter to
+   * @return MSPACK_ERR_OK if all is OK, or MSPACK_ERR_ARGS if there
+   *         is a problem with either parameter or value.
+   * @see generate()
+   */
+  int (*set_param)(struct mschm_compressor *self,
+                   int param,
+                   unsigned int value);
+
+  /**
+   * Returns the error code set by the most recently called method.
+   *
+   * @param  self     a self-referential pointer to the mschm_compressor
+   *                  instance being called
+   * @return the most recent error code
+   * @see set_param(), generate()
+   */
+  int (*last_error)(struct mschm_compressor *self);
+};
+
+/**
+ * A decompressor for .CHM (Microsoft HTMLHelp) files
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_chm_decompressor(), mspack_destroy_chm_decompressor()
+ */
+struct mschm_decompressor {
+  /**
+   * Opens a CHM helpfile and reads its contents.
+   *
+   * If the file opened is a valid CHM helpfile, all headers will be read
+   * and a mschmd_header structure will be returned, with a full list of
+   * files.
+   *
+   * In the case of an error occuring, NULL is returned and the error code
+   * is available from last_error().
+   *
+   * The filename pointer should be considered "in use" until close() is
+   * called on the CHM helpfile.
+   *
+   * @param  self     a self-referential pointer to the mschm_decompressor
+   *                  instance being called
+   * @param  filename the filename of the CHM helpfile. This is passed
+   *                  directly to mspack_system::open().
+   * @return a pointer to a mschmd_header structure, or NULL on failure
+   * @see close()
+   */
+  struct mschmd_header *(*open)(struct mschm_decompressor *self,
+                                const char *filename);
+
+  /**
+   * Closes a previously opened CHM helpfile.
+   *
+   * This closes a CHM helpfile, frees the mschmd_header and all
+   * mschmd_file structures associated with it (if any). This works on
+   * both helpfiles opened with open() and helpfiles opened with
+   * fast_open().
+   *
+   * The CHM header pointer is now invalid and cannot be used again. All
+   * mschmd_file pointers referencing that CHM are also now invalid, and
+   * cannot be used again.
+   *
+   * @param  self     a self-referential pointer to the mschm_decompressor
+   *                  instance being called
+   * @param  chm      the CHM helpfile to close
+   * @see open(), fast_open()
+   */
+  void (*close)(struct mschm_decompressor *self,
+                struct mschmd_header *chm);
+
+  /**
+   * Extracts a file from a CHM helpfile.
+   *
+   * This extracts a file from a CHM helpfile and writes it to the given
+   * filename. The filename of the file, mscabd_file::filename, is not
+   * used by extract(), but can be used by the caller as a guide for
+   * constructing an appropriate filename.
+   *
+   * This method works both with files found in the mschmd_header::files
+   * and mschmd_header::sysfiles list and mschmd_file structures generated
+   * on the fly by fast_find().
+   *
+   * @param  self     a self-referential pointer to the mschm_decompressor
+   *                  instance being called
+   * @param  file     the file to be decompressed
+   * @param  filename the filename of the file being written to
+   * @return an error code, or MSPACK_ERR_OK if successful
+   */
+  int (*extract)(struct mschm_decompressor *self,
+                 struct mschmd_file *file,
+                 const char *filename);
+
+  /**
+   * Returns the error code set by the most recently called method.
+   *
+   * This is useful for open() and fast_open(), which do not return an
+   * error code directly.
+   *
+   * @param  self     a self-referential pointer to the mschm_decompressor
+   *                  instance being called
+   * @return the most recent error code
+   * @see open(), extract()
+   */
+  int (*last_error)(struct mschm_decompressor *self);
+
+  /**
+   * Opens a CHM helpfile quickly.
+   *
+   * If the file opened is a valid CHM helpfile, only essential headers
+   * will be read. A mschmd_header structure will be still be returned, as
+   * with open(), but the mschmd_header::files field will be NULL. No
+   * files details will be automatically read.  The fast_find() method
+   * must be used to obtain file details.
+   *
+   * In the case of an error occuring, NULL is returned and the error code
+   * is available from last_error().
+   *
+   * The filename pointer should be considered "in use" until close() is
+   * called on the CHM helpfile.
+   *
+   * @param  self     a self-referential pointer to the mschm_decompressor
+   *                  instance being called
+   * @param  filename the filename of the CHM helpfile. This is passed
+   *                  directly to mspack_system::open().
+   * @return a pointer to a mschmd_header structure, or NULL on failure
+   * @see open(), close(), fast_find(), extract()
+   */
+  struct mschmd_header *(*fast_open)(struct mschm_decompressor *self,
+                                     const char *filename);
+
+  /**
+   * Finds file details quickly.
+   *
+   * Instead of reading all CHM helpfile headers and building a list of
+   * files, fast_open() and fast_find() are intended for finding file
+   * details only when they are needed. The CHM file format includes an
+   * on-disk file index to allow this.
+   *
+   * Given a case-sensitive filename, fast_find() will search the on-disk
+   * index for that file.
+   *
+   * If the file was found, the caller-provided mschmd_file structure will
+   * be filled out like so:
+   * - section: the correct value for the found file
+   * - offset: the correct value for the found file
+   * - length: the correct value for the found file
+   * - all other structure elements: NULL or 0
+   *
+   * If the file was not found, MSPACK_ERR_OK will still be returned as the
+   * result, but the caller-provided structure will be filled out like so:
+   * - section: NULL
+   * - offset: 0
+   * - length: 0
+   * - all other structure elements: NULL or 0
+   *
+   * This method is intended to be used in conjunction with CHM helpfiles
+   * opened with fast_open(), but it also works with helpfiles opened
+   * using the regular open().
+   *
+   * @param  self     a self-referential pointer to the mschm_decompressor
+   *                  instance being called
+   * @param  chm      the CHM helpfile to search for the file
+   * @param  filename the filename of the file to search for
+   * @param  f_ptr    a pointer to a caller-provded mschmd_file structure
+   * @param  f_size   <tt>sizeof(struct mschmd_file)</tt>
+   * @return an error code, or MSPACK_ERR_OK if successful
+   * @see open(), close(), fast_find(), extract()
+   */
+  int (*fast_find)(struct mschm_decompressor *self,
+                   struct mschmd_header *chm,
+                   const char *filename,
+                   struct mschmd_file *f_ptr,
+                   int f_size);
+};
+
+/* --- support for .LIT (EBook) file format -------------------------------- */
+
+/** TODO */
+struct mslit_compressor {
+  int dummy; 
+};
+
+/** TODO */
+struct mslit_decompressor {
+  int dummy; 
+};
+
+
+/* --- support for .HLP (MS Help) file format ------------------------------ */
+
+/** TODO */
+struct mshlp_compressor {
+  int dummy; 
+};
+
+/** TODO */
+struct mshlp_decompressor {
+  int dummy; 
+};
+
+
+/* --- support for SZDD file format ---------------------------------------- */
+
+/** msszdd_compressor::set_param() parameter: the missing character */
+#define MSSZDDC_PARAM_MISSINGCHAR (0)
+
+/** msszddd_header::format value - a regular SZDD file */
+#define MSSZDD_FMT_NORMAL (0)
+
+/** msszddd_header::format value - a special QBasic SZDD file */
+#define MSSZDD_FMT_QBASIC (1)
+
+/**
+ * A structure which represents an SZDD compressed file.
+ *
+ * All fields are READ ONLY.
+ */
+struct msszddd_header {
+  /** The file format; either #MSSZDD_FMT_NORMAL or #MSSZDD_FMT_QBASIC */
+  int format;
+
+  /** The amount of data in the SZDD file once uncompressed. */
+  off_t length;
+
+  /**
+   * The last character in the filename, traditionally replaced with an
+   * underscore to show the file is compressed. The null character is used
+   * to show that this character has not been stored (e.g. because the
+   * filename is not known). Generally, only characters that may appear in
+   * an MS-DOS filename (except ".") are valid.
+   */
+  char missing_char;
+};
+
+/**
+ * A compressor for the SZDD file format.
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_szdd_compressor(), mspack_destroy_szdd_compressor()
+ */
+struct msszdd_compressor {
+  /**
+   * Reads an input file and creates a compressed output file in the
+   * SZDD compressed file format. The SZDD compression format is quick
+   * but gives poor compression. It is possible for the compressed output
+   * file to be larger than the input file.
+   *
+   * Conventionally, SZDD compressed files have the final character in
+   * their filename replaced with an underscore, to show they are
+   * compressed.  The missing character is stored in the compressed file
+   * itself. This is due to the restricted filename conventions of MS-DOS,
+   * most operating systems, such as UNIX, simply append another file
+   * extension to the existing filename. As mspack does not deal with
+   * filenames, this is left up to you. If you wish to set the missing
+   * character stored in the file header, use set_param() with the
+   * #MSSZDDC_PARAM_MISSINGCHAR parameter.
+   *
+   * "Stream" compression (where the length of the input data is not
+   * known) is not possible. The length of the input data is stored in the
+   * header of the SZDD file and must therefore be known before any data
+   * is compressed. Due to technical limitations of the file format, the
+   * maximum size of uncompressed file that will be accepted is 2147483647
+   * bytes.
+   *
+   * @param  self    a self-referential pointer to the msszdd_compressor
+   *                 instance being called
+   * @param  input   the name of the file to compressed. This is passed
+   *                 passed directly to mspack_system::open()
+   * @param  output  the name of the file to write compressed data to.
+   *                 This is passed directly to mspack_system::open().
+   * @param  length  the length of the uncompressed file, or -1 to indicate
+   *                 that this should be determined automatically by using
+   *                 mspack_system::seek() on the input file.
+   * @return an error code, or MSPACK_ERR_OK if successful
+   * @see set_param()
+   */
+  int (*compress)(struct msszdd_compressor *self,
+                  const char *input,
+                  const char *output,
+                  off_t length);
+
+  /**
+   * Sets an SZDD compression engine parameter.
+   *
+   * The following parameters are defined:
+
+   * - #MSSZDDC_PARAM_CHARACTER: the "missing character", the last character
+   *   in the uncompressed file's filename, which is traditionally replaced
+   *   with an underscore to show the file is compressed. Traditionally,
+   *   this can only be a character that is a valid part of an MS-DOS,
+   *   filename, but libmspack permits any character between 0x00 and 0xFF
+   *   to be stored. 0x00 is the default, and it represents "no character
+   *   stored".
+   *
+   * @param  self     a self-referential pointer to the msszdd_compressor
+   *                  instance being called
+   * @param  param    the parameter to set
+   * @param  value    the value to set the parameter to
+   * @return MSPACK_ERR_OK if all is OK, or MSPACK_ERR_ARGS if there
+   *         is a problem with either parameter or value.
+   * @see compress()
+   */
+  int (*set_param)(struct msszdd_compressor *self,
+                   int param,
+                   unsigned int value);
+
+  /**
+   * Returns the error code set by the most recently called method.
+   *
+   * @param  self     a self-referential pointer to the msszdd_compressor
+   *                  instance being called
+   * @return the most recent error code
+   * @see compress()
+   */
+  int (*last_error)(struct mschm_decompressor *self);
+};
+
+/**
+ * A decompressor for SZDD compressed files.
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_szdd_decompressor(), mspack_destroy_szdd_decompressor()
+ */
+struct msszdd_decompressor {
+  /**
+   * Opens a SZDD file and reads the header.
+   *
+   * If the file opened is a valid SZDD file, all headers will be read and
+   * a msszddd_header structure will be returned.
+   *
+   * In the case of an error occuring, NULL is returned and the error code
+   * is available from last_error().
+   *
+   * The filename pointer should be considered "in use" until close() is
+   * called on the SZDD file.
+   *
+   * @param  self     a self-referential pointer to the msszdd_decompressor
+   *                  instance being called
+   * @param  filename the filename of the SZDD compressed file. This is
+   *                  passed directly to mspack_system::open().
+   * @return a pointer to a msszddd_header structure, or NULL on failure
+   * @see close()
+   */
+  struct msszddd_header *(*open)(struct msszdd_decompressor *self,
+                                 const char *filename);
+
+  /**
+   * Closes a previously opened SZDD file.
+   *
+   * This closes a SZDD file and frees the msszddd_header associated with
+   * it.
+   *
+   * The SZDD header pointer is now invalid and cannot be used again.
+   *
+   * @param  self     a self-referential pointer to the msszdd_decompressor
+   *                  instance being called
+   * @param  szdd     the SZDD file to close
+   * @see open()
+   */
+  void (*close)(struct msszdd_decompressor *self,
+                struct msszddd_header *szdd);
+
+  /**
+   * Extracts the compressed data from a SZDD file.
+   *
+   * This decompresses the compressed SZDD data stream and writes it to
+   * an output file.
+   *
+   * @param  self     a self-referential pointer to the msszdd_decompressor
+   *                  instance being called
+   * @param  szdd     the SZDD file to extract data from
+   * @param  filename the filename to write the decompressed data to. This
+   *                  is passed directly to mspack_system::open().
+   * @return an error code, or MSPACK_ERR_OK if successful
+   */
+  int (*extract)(struct msszdd_decompressor *self,
+                 struct msszddd_header *szdd,
+                 const char *filename);
+
+  /**
+   * Decompresses an SZDD file to an output file in one step.
+   *
+   * This opens an SZDD file as input, reads the header, then decompresses
+   * the compressed data immediately to an output file, finally closing
+   * both the input and output file. It is more convenient to use than
+   * open() then extract() then close(), if you do not need to know the
+   * SZDD output size or missing character.
+   *
+   * @param  self     a self-referential pointer to the msszdd_decompressor
+   *                  instance being called
+   * @param  input    the filename of the input SZDD file. This is passed
+   *                  directly to mspack_system::open().
+   * @param  output   the filename to write the decompressed data to. This
+   *                  is passed directly to mspack_system::open().
+   * @return an error code, or MSPACK_ERR_OK if successful
+   */
+  int (*decompress)(struct msszdd_decompressor *self,
+                    const char *input,
+                    const char *output);
+
+  /**
+   * Returns the error code set by the most recently called method.
+   *
+   * This is useful for open() which does not return an
+   * error code directly.
+   *
+   * @param  self     a self-referential pointer to the msszdd_decompressor
+   *                  instance being called
+   * @return the most recent error code
+   * @see open(), extract(), decompress()
+   */
+  int (*last_error)(struct msszdd_decompressor *self);
+};
+
+/* --- support for KWAJ file format ---------------------------------------- */
+
+/** mskwaj_compressor::set_param() parameter: compression type */
+#define MSKWAJC_PARAM_COMP_TYPE  (0)
+
+/** mskwaj_compressor::set_param() parameter: include the length of the
+ * uncompressed file in the header?
+ */
+#define MSKWAJC_PARAM_INCLUDE_LENGTH (1)
+
+/** KWAJ compression type: no compression. */
+#define MSKWAJ_COMP_NONE (0)
+/** KWAJ compression type: no compression, 0xFF XOR "encryption". */
+#define MSKWAJ_COMP_XOR (1)
+/** KWAJ compression type: LZSS (same method as SZDD) */
+#define MSKWAJ_COMP_SZDD (2)
+/** KWAJ compression type: LZ+Huffman compression */
+#define MSKWAJ_COMP_LZH (3)
+/** KWAJ compression type: MSZIP */
+#define MSKWAJ_COMP_MSZIP (4)
+
+/** KWAJ optional header flag: decompressed file length is included */
+#define MSKWAJ_HDR_HASLENGTH (0x01)
+
+/** KWAJ optional header flag: unknown 2-byte structure is included */
+#define MSKWAJ_HDR_HASUNKNOWN1 (0x02)
+
+/** KWAJ optional header flag: unknown multi-sized structure is included */
+#define MSKWAJ_HDR_HASUNKNOWN2 (0x04)
+
+/** KWAJ optional header flag: file name (no extension) is included */
+#define MSKWAJ_HDR_HASFILENAME (0x08)
+
+/** KWAJ optional header flag: file extension is included */
+#define MSKWAJ_HDR_HASFILEEXT (0x10)
+
+/** KWAJ optional header flag: extra text is included */
+#define MSKWAJ_HDR_HASEXTRATEXT (0x20)
+
+/**
+ * A structure which represents an KWAJ compressed file.
+ *
+ * All fields are READ ONLY.
+ */
+struct mskwajd_header {
+  /** The compression type; should be one of #MSKWAJ_COMP_NONE,
+   * #MSKWAJ_COMP_XOR, #MSKWAJ_COMP_SZDD or #MSKWAJ_COMP_LZH
+   */
+  unsigned short comp_type;
+
+  /** The offset in the file where the compressed data stream begins */
+  off_t data_offset;
+
+  /** Flags indicating which optional headers were included. */
+  int headers;
+
+  /** The amount of uncompressed data in the file, or 0 if not present. */
+  off_t length;
+
+  /** output filename, or NULL if not present */
+  char *filename;
+
+  /** extra uncompressed data (usually text) in the header.
+   * This data can contain nulls so use extra_length to get the size.
+   */
+  char *extra;
+
+  /** length of extra uncompressed data in the header */
+  unsigned short extra_length;
+};
+
+/**
+ * A compressor for the KWAJ file format.
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_kwaj_compressor(), mspack_destroy_kwaj_compressor()
+ */
+struct mskwaj_compressor {
+  /**
+   * Reads an input file and creates a compressed output file in the
+   * KWAJ compressed file format. The KWAJ compression format is quick
+   * but gives poor compression. It is possible for the compressed output
+   * file to be larger than the input file.
+   *
+   * @param  self    a self-referential pointer to the mskwaj_compressor
+   *                 instance being called
+   * @param  input   the name of the file to compressed. This is passed
+   *                 passed directly to mspack_system::open()
+   * @param  output  the name of the file to write compressed data to.
+   *                 This is passed directly to mspack_system::open().
+   * @param  length  the length of the uncompressed file, or -1 to indicate
+   *                 that this should be determined automatically by using
+   *                 mspack_system::seek() on the input file.
+   * @return an error code, or MSPACK_ERR_OK if successful
+   * @see set_param()
+   */
+  int (*compress)(struct mskwaj_compressor *self,
+                  const char *input,
+                  const char *output,
+                  off_t length);
+
+  /**
+   * Sets an KWAJ compression engine parameter.
+   *
+   * The following parameters are defined:
+   *
+   * - #MSKWAJC_PARAM_COMP_TYPE: the compression method to use. Must
+   *   be one of #MSKWAJC_COMP_NONE, #MSKWAJC_COMP_XOR, #MSKWAJ_COMP_SZDD
+   *   or #MSKWAJ_COMP_LZH. The default is #MSKWAJ_COMP_LZH.
+   *
+   * - #MSKWAJC_PARAM_INCLUDE_LENGTH: a boolean; should the compressed
+   *   output file should include the uncompressed length of the input
+   *   file in the header? This adds 4 bytes to the size of the output
+   *   file. A value of zero says "no", non-zero says "yes". The default
+   *   is "no".
+   *
+   * @param  self     a self-referential pointer to the mskwaj_compressor
+   *                  instance being called
+   * @param  param    the parameter to set
+   * @param  value    the value to set the parameter to
+   * @return MSPACK_ERR_OK if all is OK, or MSPACK_ERR_ARGS if there
+   *         is a problem with either parameter or value.
+   * @see generate()
+   */
+  int (*set_param)(struct mskwaj_compressor *self,
+                   int param,
+                   unsigned int value);
+
+
+  /**
+   * Sets the original filename of the file before compression,
+   * which will be stored in the header of the output file.
+   *
+   * The filename should be a null-terminated string, it must be an
+   * MS-DOS "8.3" type filename (up to 8 bytes for the filename, then
+   * optionally a "." and up to 3 bytes for a filename extension).
+   *
+   * If NULL is passed as the filename, no filename is included in the
+   * header. This is the default.
+   *
+   * @param  self     a self-referential pointer to the mskwaj_compressor
+   *                  instance being called
+   * @param  filename the original filename to use
+   * @return MSPACK_ERR_OK if all is OK, or MSPACK_ERR_ARGS if the
+   *         filename is too long
+   */
+  int (*set_filename)(struct mskwaj_compressor *self,
+                      const char *filename);
+
+  /**
+   * Sets arbitrary data that will be stored in the header of the
+   * output file, uncompressed. It can be up to roughly 64 kilobytes,
+   * as the overall size of the header must not exceed 65535 bytes.
+   * The data can contain null bytes if desired.
+   *
+   * If NULL is passed as the data pointer, or zero is passed as the
+   * length, no extra data is included in the header. This is the
+   * default.
+   *
+   * @param  self     a self-referential pointer to the mskwaj_compressor
+   *                  instance being called
+   * @param  data     a pointer to the data to be stored in the header
+   * @param  bytes    the length of the data in bytes
+   * @return MSPACK_ERR_OK if all is OK, or MSPACK_ERR_ARGS extra data
+   *         is too long
+   */
+  int (*set_extra_data)(struct mskwaj_compressor *self,
+                        void *data,
+                        size_t bytes);
+
+  /**
+   * Returns the error code set by the most recently called method.
+   *
+   * @param  self     a self-referential pointer to the mskwaj_compressor
+   *                  instance being called
+   * @return the most recent error code
+   * @see compress()
+   */
+  int (*last_error)(struct mschm_decompressor *self);
+};
+
+/**
+ * A decompressor for KWAJ compressed files.
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_kwaj_decompressor(), mspack_destroy_kwaj_decompressor()
+ */
+struct mskwaj_decompressor {
+  /**
+   * Opens a KWAJ file and reads the header.
+   *
+   * If the file opened is a valid KWAJ file, all headers will be read and
+   * a mskwajd_header structure will be returned.
+   *
+   * In the case of an error occuring, NULL is returned and the error code
+   * is available from last_error().
+   *
+   * The filename pointer should be considered "in use" until close() is
+   * called on the KWAJ file.
+   *
+   * @param  self     a self-referential pointer to the mskwaj_decompressor
+   *                  instance being called
+   * @param  filename the filename of the KWAJ compressed file. This is
+   *                  passed directly to mspack_system::open().
+   * @return a pointer to a mskwajd_header structure, or NULL on failure
+   * @see close()
+   */
+  struct mskwajd_header *(*open)(struct mskwaj_decompressor *self,
+                                 const char *filename);
+
+  /**
+   * Closes a previously opened KWAJ file.
+   *
+   * This closes a KWAJ file and frees the mskwajd_header associated
+   * with it. The KWAJ header pointer is now invalid and cannot be
+   * used again.
+   *
+   * @param  self     a self-referential pointer to the mskwaj_decompressor
+   *                  instance being called
+   * @param  kwaj     the KWAJ file to close
+   * @see open()
+   */
+  void (*close)(struct mskwaj_decompressor *self,
+                struct mskwajd_header *kwaj);
+
+  /**
+   * Extracts the compressed data from a KWAJ file.
+   *
+   * This decompresses the compressed KWAJ data stream and writes it to
+   * an output file.
+   *
+   * @param  self     a self-referential pointer to the mskwaj_decompressor
+   *                  instance being called
+   * @param  kwaj     the KWAJ file to extract data from
+   * @param  filename the filename to write the decompressed data to. This
+   *                  is passed directly to mspack_system::open().
+   * @return an error code, or MSPACK_ERR_OK if successful
+   */
+  int (*extract)(struct mskwaj_decompressor *self,
+                 struct mskwajd_header *kwaj,
+                 const char *filename);
+
+  /**
+   * Decompresses an KWAJ file to an output file in one step.
+   *
+   * This opens an KWAJ file as input, reads the header, then decompresses
+   * the compressed data immediately to an output file, finally closing
+   * both the input and output file. It is more convenient to use than
+   * open() then extract() then close(), if you do not need to know the
+   * KWAJ output size or output filename.
+   *
+   * @param  self     a self-referential pointer to the mskwaj_decompressor
+   *                  instance being called
+   * @param  input    the filename of the input KWAJ file. This is passed
+   *                  directly to mspack_system::open().
+   * @param  output   the filename to write the decompressed data to. This
+   *                  is passed directly to mspack_system::open().
+   * @return an error code, or MSPACK_ERR_OK if successful
+   */
+  int (*decompress)(struct mskwaj_decompressor *self,
+                    const char *input,
+                    const char *output);
+
+  /**
+   * Returns the error code set by the most recently called method.
+   *
+   * This is useful for open() which does not return an
+   * error code directly.
+   *
+   * @param  self     a self-referential pointer to the mskwaj_decompressor
+   *                  instance being called
+   * @return the most recent error code
+   * @see open(), search()
+   */
+  int (*last_error)(struct mskwaj_decompressor *self);
+};
+
+/* --- support for .LZX (Offline Address Book) file format ----------------- */
+
+/**
+ * A compressor for the Offline Address Book (OAB) format.
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_oab_compressor(), mspack_destroy_oab_compressor()
+ */
+struct msoab_compressor {
+  /**
+   * Compress a full OAB file.
+   *
+   * The input file will be read and the compressed contents written to the
+   * output file.
+   *
+   * @param  self     a self-referential pointer to the msoab_decompressor
+   *                  instance being called
+   * @param  input    the filename of the input file. This is passed
+   *                  directly to mspack_system::open().
+   * @param  output   the filename of the output file. This is passed
+   *                  directly to mspack_system::open().
+   * @return an error code, or MSPACK_ERR_OK if successful
+   */
+  int (*compress) (struct msoab_compressor *self,
+                   const char *input,
+                   const char *output);
+
+  /**
+   * Generate a compressed incremental OAB patch file.
+   *
+   * The two uncompressed files "input" and "base" will be read, and an
+   * incremental patch to generate "input" from "base" will be written to
+   * the output file.
+   *
+   * @param  self     a self-referential pointer to the msoab_compressor
+   *                  instance being called
+   * @param  input    the filename of the input file containing the new
+   *                  version of its contents. This is passed directly
+   *                  to mspack_system::open().
+   * @param  base     the filename of the original base file containing
+   *                  the old version of its contents, against which the
+   *                  incremental patch shall generated. This is passed
+   *                  directly to mspack_system::open().
+   * @param  output   the filename of the output file. This is passed
+   *                  directly to mspack_system::open().
+   * @return an error code, or MSPACK_ERR_OK if successful
+   */
+  int (*compress_incremental) (struct msoab_compressor *self,
+                               const char *input,
+                               const char *base,
+                               const char *output);
+};
+
+/**
+ * A decompressor for .LZX (Offline Address Book) files
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_oab_decompressor(), mspack_destroy_oab_decompressor()
+ */
+struct msoab_decompressor {
+  /**
+   * Decompresses a full Offline Address Book file.
+   *
+   * If the input file is a valid compressed Offline Address Book file, 
+   * it will be read and the decompressed contents will be written to
+   * the output file.
+   *
+   * @param  self     a self-referential pointer to the msoab_decompressor
+   *                  instance being called
+   * @param  input    the filename of the input file. This is passed
+   *                  directly to mspack_system::open().
+   * @param  output   the filename of the output file. This is passed
+   *                  directly to mspack_system::open().
+   * @return an error code, or MSPACK_ERR_OK if successful
+   */
+  int (*decompress) (struct msoab_decompressor *self,
+                     const char *input,
+                     const char *output);
+
+  /**
+   * Decompresses an Offline Address Book with an incremental patch file.
+   *
+   * This requires both a full UNCOMPRESSED Offline Address Book file to
+   * act as the "base", and a compressed incremental patch file as input.
+   * If the input file is valid, it will be decompressed with reference to
+   * the base file, and the decompressed contents will be written to the
+   * output file.
+   *
+   * There is no way to tell what the right base file is for the given
+   * incremental patch, but if you get it wrong, this will usually result
+   * in incorrect data being decompressed, which will then fail a checksum
+   * test.
+   *
+   * @param  self     a self-referential pointer to the msoab_decompressor
+   *                  instance being called
+   * @param  input    the filename of the input file. This is passed
+   *                  directly to mspack_system::open().
+   * @param  base     the filename of the base file to which the
+   *                  incremental patch shall be applied. This is passed
+   *                  directly to mspack_system::open().
+   * @param  output   the filename of the output file. This is passed
+   *                  directly to mspack_system::open().
+   * @return an error code, or MSPACK_ERR_OK if successful
+   */
+  int (*decompress_incremental) (struct msoab_decompressor *self,
+                                 const char *input,
+                                 const char *base,
+                                 const char *output);
+};
+
+#ifdef __cplusplus
+}
 #endif
 
 #endif
diff --git a/third_party/mspack/readbits.h b/third_party/mspack/readbits.h
new file mode 100644
index 000000000..9b237a369
--- /dev/null
+++ b/third_party/mspack/readbits.h
@@ -0,0 +1,207 @@
+/* This file is part of libmspack.
+ * (C) 2003-2010 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_READBITS_H
+#define MSPACK_READBITS_H 1
+
+/* this header defines macros that read data streams by
+ * the individual bits
+ *
+ * INIT_BITS         initialises bitstream state in state structure
+ * STORE_BITS        stores bitstream state in state structure
+ * RESTORE_BITS      restores bitstream state from state structure
+ * ENSURE_BITS(n)    ensure there are at least N bits in the bit buffer
+ * READ_BITS(var,n)  takes N bits from the buffer and puts them in var
+ * PEEK_BITS(n)      extracts without removing N bits from the bit buffer
+ * REMOVE_BITS(n)    removes N bits from the bit buffer
+ *
+ * READ_BITS simply calls ENSURE_BITS, PEEK_BITS and REMOVE_BITS,
+ * which means it's limited to reading the number of bits you can
+ * ensure at any one time. It also fails if asked to read zero bits.
+ * If you need to read zero bits, or more bits than can be ensured in
+ * one go, use READ_MANY_BITS instead.
+ *
+ * These macros have variable names baked into them, so to use them
+ * you have to define some macros:
+ * - BITS_TYPE: the type name of your state structure
+ * - BITS_VAR: the variable that points to your state structure
+ * - define BITS_ORDER_MSB if bits are read from the MSB, or
+ *   define BITS_ORDER_LSB if bits are read from the LSB
+ * - READ_BYTES: some code that reads more data into the bit buffer,
+ *   it should use READ_IF_NEEDED (calls read_input if the byte buffer
+ *   is empty), then INJECT_BITS(data,n) to put data from the byte
+ *   buffer into the bit buffer.
+ *
+ * You also need to define some variables and structure members:
+ * - unsigned char *i_ptr;    // current position in the byte buffer
+ * - unsigned char *i_end;    // end of the byte buffer
+ * - unsigned int bit_buffer; // the bit buffer itself
+ * - unsigned int bits_left;  // number of bits remaining
+ *
+ * If you use read_input() and READ_IF_NEEDED, they also expect these
+ * structure members:
+ * - struct mspack_system *sys;  // to access sys->read()
+ * - unsigned int error;         // to record/return read errors
+ * - unsigned char input_end;    // to mark reaching the EOF
+ * - unsigned char *inbuf;       // the input byte buffer
+ * - unsigned int inbuf_size;    // the size of the input byte buffer
+ *
+ * Your READ_BYTES implementation should read data from *i_ptr and
+ * put them in the bit buffer. READ_IF_NEEDED will call read_input()
+ * if i_ptr reaches i_end, and will fill up inbuf and set i_ptr to
+ * the start of inbuf and i_end to the end of inbuf.
+ *
+ * If you're reading in MSB order, the routines work by using the area
+ * beyond the MSB and the LSB of the bit buffer as a free source of
+ * zeroes when shifting. This avoids having to mask any bits. So we
+ * have to know the bit width of the bit buffer variable. We use
+ * <limits.h> and CHAR_BIT to find the size of the bit buffer in bits.
+ *
+ * If you are reading in LSB order, bits need to be masked. Normally
+ * this is done by computing the mask: N bits are masked by the value
+ * (1<<N)-1). However, you can define BITS_LSB_TABLE to use a lookup
+ * table instead of computing this. This adds two new macros,
+ * PEEK_BITS_T and READ_BITS_T which work the same way as PEEK_BITS
+ * and READ_BITS, except they use this lookup table. This is useful if
+ * you need to look up a number of bits that are only known at
+ * runtime, so the bit mask can't be turned into a constant by the
+ * compiler.
+
+ * The bit buffer datatype should be at least 32 bits wide: it must be
+ * possible to ENSURE_BITS(17), so it must be possible to add 16 new bits
+ * to the bit buffer when the bit buffer already has 1 to 15 bits left.
+ */
+
+#ifndef BITS_VAR
+# error "define BITS_VAR as the state structure poiner variable name"
+#endif
+#ifndef BITS_TYPE
+# error "define BITS_TYPE as the state structure type"
+#endif
+#if defined(BITS_ORDER_MSB) && defined(BITS_ORDER_LSB)
+# error "you must define either BITS_ORDER_MSB or BITS_ORDER_LSB"
+#else
+# if !(defined(BITS_ORDER_MSB) || defined(BITS_ORDER_LSB))
+#  error "you must define BITS_ORDER_MSB or BITS_ORDER_LSB"
+# endif
+#endif
+
+#if HAVE_LIMITS_H
+# include <limits.h>
+#endif
+#ifndef CHAR_BIT
+# define CHAR_BIT (8)
+#endif
+#define BITBUF_WIDTH (sizeof(bit_buffer) * CHAR_BIT)
+
+#define INIT_BITS do {                          \
+    BITS_VAR->i_ptr      = &BITS_VAR->inbuf[0]; \
+    BITS_VAR->i_end      = &BITS_VAR->inbuf[0]; \
+    BITS_VAR->bit_buffer = 0;                   \
+    BITS_VAR->bits_left  = 0;                   \
+    BITS_VAR->input_end  = 0;                   \
+} while (0)
+
+#define STORE_BITS do {                 \
+    BITS_VAR->i_ptr      = i_ptr;       \
+    BITS_VAR->i_end      = i_end;       \
+    BITS_VAR->bit_buffer = bit_buffer;  \
+    BITS_VAR->bits_left  = bits_left;   \
+} while (0)
+
+#define RESTORE_BITS do {               \
+    i_ptr      = BITS_VAR->i_ptr;       \
+    i_end      = BITS_VAR->i_end;       \
+    bit_buffer = BITS_VAR->bit_buffer;  \
+    bits_left  = BITS_VAR->bits_left;   \
+} while (0)
+
+#define ENSURE_BITS(nbits) do {                 \
+    while (bits_left < (nbits)) READ_BYTES;     \
+} while (0)
+
+#define READ_BITS(val, nbits) do {              \
+    ENSURE_BITS(nbits);                         \
+    (val) = PEEK_BITS(nbits);                   \
+    REMOVE_BITS(nbits);                         \
+} while (0)
+
+#define READ_MANY_BITS(val, bits) do {                          \
+    unsigned char needed = (bits), bitrun;                      \
+    (val) = 0;                                                  \
+    while (needed > 0) {                                        \
+        if (bits_left <= (BITBUF_WIDTH - 16)) READ_BYTES;       \
+        bitrun = (bits_left < needed) ? bits_left : needed;     \
+        (val) = ((val) << bitrun) | PEEK_BITS(bitrun);          \
+        REMOVE_BITS(bitrun);                                    \
+        needed -= bitrun;                                       \
+    }                                                           \
+} while (0)
+
+#ifdef BITS_ORDER_MSB
+# define PEEK_BITS(nbits)   (bit_buffer >> (BITBUF_WIDTH - (nbits)))
+# define REMOVE_BITS(nbits) ((bit_buffer <<= (nbits)), (bits_left -= (nbits)))
+# define INJECT_BITS(bitdata,nbits) ((bit_buffer |= \
+    (bitdata) << (BITBUF_WIDTH - (nbits) - bits_left)), (bits_left += (nbits)))
+#else /* BITS_ORDER_LSB */
+# define PEEK_BITS(nbits)   (bit_buffer & ((1 << (nbits))-1))
+# define REMOVE_BITS(nbits) ((bit_buffer >>= (nbits)), (bits_left -= (nbits)))
+# define INJECT_BITS(bitdata,nbits) ((bit_buffer |= \
+    (bitdata) << bits_left), (bits_left += (nbits)))
+#endif
+
+#ifdef BITS_LSB_TABLE
+/* lsb_bit_mask[n] = (1 << n) - 1 */
+static const unsigned short lsb_bit_mask[17] = {
+    0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
+    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
+};
+# define PEEK_BITS_T(nbits) (bit_buffer & lsb_bit_mask[(nbits)])
+# define READ_BITS_T(val, nbits) do {   \
+    ENSURE_BITS(nbits);                 \
+    (val) = PEEK_BITS_T(nbits);         \
+    REMOVE_BITS(nbits);                 \
+} while (0)
+#endif
+
+#ifndef BITS_NO_READ_INPUT
+# define READ_IF_NEEDED do {            \
+    if (i_ptr >= i_end) {               \
+        if (read_input(BITS_VAR))       \
+            return BITS_VAR->error;     \
+        i_ptr = BITS_VAR->i_ptr;        \
+        i_end = BITS_VAR->i_end;        \
+    }                                   \
+} while (0)
+
+static int read_input(BITS_TYPE *p) {
+    int read = p->sys->read(p->input, &p->inbuf[0], (int)p->inbuf_size);
+    if (read < 0) return p->error = MSPACK_ERR_READ;
+
+    /* we might overrun the input stream by asking for bits we don't use,
+     * so fake 2 more bytes at the end of input */
+    if (read == 0) {
+        if (p->input_end) {
+            D(("out of input bytes"))
+            return p->error = MSPACK_ERR_READ;
+        }
+        else {
+            read = 2;
+            p->inbuf[0] = p->inbuf[1] = 0;
+            p->input_end = 1;
+        }
+    }
+
+    /* update i_ptr and i_end */
+    p->i_ptr = &p->inbuf[0];
+    p->i_end = &p->inbuf[read];
+    return MSPACK_ERR_OK;
+}
+#endif
+#endif
diff --git a/third_party/mspack/readhuff.h b/third_party/mspack/readhuff.h
new file mode 100644
index 000000000..4d9422578
--- /dev/null
+++ b/third_party/mspack/readhuff.h
@@ -0,0 +1,172 @@
+/* This file is part of libmspack.
+ * (C) 2003-2014 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_READHUFF_H
+#define MSPACK_READHUFF_H 1
+
+/* This implements a fast Huffman tree decoding system. */
+
+#if !(defined(BITS_ORDER_MSB) || defined(BITS_ORDER_LSB))
+# error "readhuff.h is used in conjunction with readbits.h, include that first"
+#endif
+#if !(defined(TABLEBITS) && defined(MAXSYMBOLS))
+# error "define TABLEBITS(tbl) and MAXSYMBOLS(tbl) before using readhuff.h"
+#endif
+#if !(defined(HUFF_TABLE) && defined(HUFF_LEN))
+# error "define HUFF_TABLE(tbl) and HUFF_LEN(tbl) before using readhuff.h"
+#endif
+#ifndef HUFF_ERROR
+# error "define HUFF_ERROR before using readhuff.h"
+#endif
+#ifndef HUFF_MAXBITS
+# define HUFF_MAXBITS 16
+#endif
+
+/* Decodes the next huffman symbol from the input bitstream into var.
+ * Do not use this macro on a table unless build_decode_table() succeeded.
+ */
+#define READ_HUFFSYM(tbl, var) do {                     \
+    ENSURE_BITS(HUFF_MAXBITS);                          \
+    sym = HUFF_TABLE(tbl, PEEK_BITS(TABLEBITS(tbl)));   \
+    if (sym >= MAXSYMBOLS(tbl)) HUFF_TRAVERSE(tbl);     \
+    (var) = sym;                                        \
+    i = HUFF_LEN(tbl, sym);                             \
+    REMOVE_BITS(i);                                     \
+} while (0)
+
+#ifdef BITS_ORDER_LSB
+# define HUFF_TRAVERSE(tbl) do {                        \
+    i = TABLEBITS(tbl) - 1;                             \
+    do {                                                \
+        if (i++ > HUFF_MAXBITS) HUFF_ERROR;             \
+        sym = HUFF_TABLE(tbl,                           \
+            (sym << 1) | ((bit_buffer >> i) & 1));      \
+    } while (sym >= MAXSYMBOLS(tbl));                   \
+} while (0)
+#else
+#define HUFF_TRAVERSE(tbl) do {                         \
+    i = 1 << (BITBUF_WIDTH - TABLEBITS(tbl));           \
+    do {                                                \
+        if ((i >>= 1) == 0) HUFF_ERROR;                 \
+        sym = HUFF_TABLE(tbl,                           \
+            (sym << 1) | ((bit_buffer & i) ? 1 : 0));   \
+    } while (sym >= MAXSYMBOLS(tbl));                   \
+} while (0)
+#endif
+
+/* make_decode_table(nsyms, nbits, length[], table[])
+ *
+ * This function was originally coded by David Tritscher.
+ * It builds a fast huffman decoding table from
+ * a canonical huffman code lengths table.
+ *
+ * nsyms  = total number of symbols in this huffman tree.
+ * nbits  = any symbols with a code length of nbits or less can be decoded
+ *          in one lookup of the table.
+ * length = A table to get code lengths from [0 to nsyms-1]
+ * table  = The table to fill up with decoded symbols and pointers.
+ *          Should be ((1<<nbits) + (nsyms*2)) in length.
+ *
+ * Returns 0 for OK or 1 for error
+ */
+static int make_decode_table(unsigned int nsyms, unsigned int nbits,
+                             unsigned char *length, unsigned short *table)
+{
+    register unsigned short sym, next_symbol;
+    register unsigned int leaf, fill;
+#ifdef BITS_ORDER_LSB
+    register unsigned int reverse;
+#endif
+    register unsigned char bit_num;
+    unsigned int pos         = 0; /* the current position in the decode table */
+    unsigned int table_mask  = 1 << nbits;
+    unsigned int bit_mask    = table_mask >> 1; /* don't do 0 length codes */
+
+    /* fill entries for codes short enough for a direct mapping */
+    for (bit_num = 1; bit_num <= nbits; bit_num++) {
+        for (sym = 0; sym < nsyms; sym++) {
+            if (length[sym] != bit_num) continue;
+#ifdef BITS_ORDER_MSB
+            leaf = pos;
+#else
+            /* reverse the significant bits */
+            fill = length[sym]; reverse = pos >> (nbits - fill); leaf = 0;
+            do {leaf <<= 1; leaf |= reverse & 1; reverse >>= 1;} while (--fill);
+#endif
+
+            if((pos += bit_mask) > table_mask) return 1; /* table overrun */
+
+            /* fill all possible lookups of this symbol with the symbol itself */
+#ifdef BITS_ORDER_MSB
+            for (fill = bit_mask; fill-- > 0;) table[leaf++] = sym;
+#else
+            fill = bit_mask; next_symbol = 1 << bit_num;
+            do { table[leaf] = sym; leaf += next_symbol; } while (--fill);
+#endif
+        }
+        bit_mask >>= 1;
+    }
+
+    /* exit with success if table is now complete */
+    if (pos == table_mask) return 0;
+
+    /* mark all remaining table entries as unused */
+    for (sym = pos; sym < table_mask; sym++) {
+#ifdef BITS_ORDER_MSB
+        table[sym] = 0xFFFF;
+#else
+        reverse = sym; leaf = 0; fill = nbits;
+        do { leaf <<= 1; leaf |= reverse & 1; reverse >>= 1; } while (--fill);
+        table[leaf] = 0xFFFF;
+#endif
+    }
+
+    /* next_symbol = base of allocation for long codes */
+    next_symbol = ((table_mask >> 1) < nsyms) ? nsyms : (table_mask >> 1);
+
+    /* give ourselves room for codes to grow by up to 16 more bits.
+     * codes now start at bit nbits+16 and end at (nbits+16-codelength) */
+    pos <<= 16;
+    table_mask <<= 16;
+    bit_mask = 1 << 15;
+
+    for (bit_num = nbits+1; bit_num <= HUFF_MAXBITS; bit_num++) {
+        for (sym = 0; sym < nsyms; sym++) {
+            if (length[sym] != bit_num) continue;
+            if (pos >= table_mask) return 1; /* table overflow */
+
+#ifdef BITS_ORDER_MSB
+            leaf = pos >> 16;
+#else
+            /* leaf = the first nbits of the code, reversed */
+            reverse = pos >> 16; leaf = 0; fill = nbits;
+            do {leaf <<= 1; leaf |= reverse & 1; reverse >>= 1;} while (--fill);
+#endif
+            for (fill = 0; fill < (bit_num - nbits); fill++) {
+                /* if this path hasn't been taken yet, 'allocate' two entries */
+                if (table[leaf] == 0xFFFF) {
+                    table[(next_symbol << 1)     ] = 0xFFFF;
+                    table[(next_symbol << 1) + 1 ] = 0xFFFF;
+                    table[leaf] = next_symbol++;
+                }
+
+                /* follow the path and select either left or right for next bit */
+                leaf = table[leaf] << 1;
+                if ((pos >> (15-fill)) & 1) leaf++;
+            }
+            table[leaf] = sym;
+            pos += bit_mask;
+        }
+        bit_mask >>= 1;
+    }
+
+    /* full table? */
+    return (pos == table_mask) ? 0 : 1;
+}
+#endif
diff --git a/third_party/mspack/system.c b/third_party/mspack/system.c
new file mode 100644
index 000000000..16aa8806d
--- /dev/null
+++ b/third_party/mspack/system.c
@@ -0,0 +1,242 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <system.h>
+
+#if !LARGEFILE_SUPPORT
+const char *largefile_msg = "library not compiled to support large files.";
+#endif
+
+
+int mspack_version(int entity) {
+  switch (entity) {
+   /* CHM decoder version 1 -> 2 changes:
+    * - added mschmd_sec_mscompressed::spaninfo
+    * - added mschmd_header::first_pmgl
+    * - added mschmd_header::last_pmgl
+    * - added mschmd_header::chunk_cache;
+    */
+  case MSPACK_VER_MSCHMD:
+  /* CAB decoder version 1 -> 2 changes:
+   * - added MSCABD_PARAM_SALVAGE
+   */
+  case MSPACK_VER_MSCABD:
+    return 2;
+  case MSPACK_VER_LIBRARY:
+  case MSPACK_VER_SYSTEM:
+  case MSPACK_VER_MSSZDDD:
+  case MSPACK_VER_MSKWAJD:
+  case MSPACK_VER_MSOABD:
+    return 1;
+  case MSPACK_VER_MSCABC:
+  case MSPACK_VER_MSCHMC:
+  case MSPACK_VER_MSLITD:
+  case MSPACK_VER_MSLITC:
+  case MSPACK_VER_MSHLPD:
+  case MSPACK_VER_MSHLPC:
+  case MSPACK_VER_MSSZDDC:
+  case MSPACK_VER_MSKWAJC:
+  case MSPACK_VER_MSOABC:
+    return 0;
+  }
+  return -1;
+}
+
+int mspack_sys_selftest_internal(int offt_size) {
+  return (sizeof(off_t) == offt_size) ? MSPACK_ERR_OK : MSPACK_ERR_SEEK;
+}
+
+/* validates a system structure */
+int mspack_valid_system(struct mspack_system *sys) {
+  return (sys != NULL) && (sys->open != NULL) && (sys->close != NULL) &&
+    (sys->read != NULL) && (sys->write != NULL) && (sys->seek != NULL) &&
+    (sys->tell != NULL) && (sys->message != NULL) && (sys->alloc != NULL) &&
+    (sys->free != NULL) && (sys->copy != NULL) && (sys->null_ptr == NULL);
+}
+
+/* returns the length of a file opened for reading */
+int mspack_sys_filelen(struct mspack_system *system,
+                       struct mspack_file *file, off_t *length)
+{
+  off_t current;
+
+  if (!system || !file || !length) return MSPACK_ERR_OPEN;
+
+  /* get current offset */
+  current = system->tell(file);
+
+  /* seek to end of file */
+  if (system->seek(file, (off_t) 0, MSPACK_SYS_SEEK_END)) {
+    return MSPACK_ERR_SEEK;
+  }
+
+  /* get offset of end of file */
+  *length = system->tell(file);
+
+  /* seek back to original offset */
+  if (system->seek(file, current, MSPACK_SYS_SEEK_START)) {
+    return MSPACK_ERR_SEEK;
+  }
+
+  return MSPACK_ERR_OK;
+}
+
+
+
+/* definition of mspack_default_system -- if the library is compiled with
+ * MSPACK_NO_DEFAULT_SYSTEM, no default system will be provided. Otherwise,
+ * an appropriate default system (e.g. the standard C library, or some native
+ * API calls)
+ */
+
+#ifdef MSPACK_NO_DEFAULT_SYSTEM
+struct mspack_system *mspack_default_system = NULL;
+#else
+
+/* implementation of mspack_default_system for standard C library */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+struct mspack_file_p {
+  FILE *fh;
+  const char *name;
+};
+
+static struct mspack_file *msp_open(struct mspack_system *self,
+                                    const char *filename, int mode)
+{
+  struct mspack_file_p *fh;
+  const char *fmode;
+
+  switch (mode) {
+  case MSPACK_SYS_OPEN_READ:   fmode = "rb";  break;
+  case MSPACK_SYS_OPEN_WRITE:  fmode = "wb";  break;
+  case MSPACK_SYS_OPEN_UPDATE: fmode = "r+b"; break;
+  case MSPACK_SYS_OPEN_APPEND: fmode = "ab";  break;
+  default: return NULL;
+  }
+
+  if ((fh = (struct mspack_file_p *) malloc(sizeof(struct mspack_file_p)))) {
+    fh->name = filename;
+    if ((fh->fh = fopen(filename, fmode))) return (struct mspack_file *) fh;
+    free(fh);
+  }
+  return NULL;
+}
+
+static void msp_close(struct mspack_file *file) {
+  struct mspack_file_p *self = (struct mspack_file_p *) file;
+  if (self) {
+    fclose(self->fh);
+    free(self);
+  }
+}
+
+static int msp_read(struct mspack_file *file, void *buffer, int bytes) {
+  struct mspack_file_p *self = (struct mspack_file_p *) file;
+  if (self && buffer && bytes >= 0) {
+    size_t count = fread(buffer, 1, (size_t) bytes, self->fh);
+    if (!ferror(self->fh)) return (int) count;
+  }
+  return -1;
+}
+
+static int msp_write(struct mspack_file *file, void *buffer, int bytes) {
+  struct mspack_file_p *self = (struct mspack_file_p *) file;
+  if (self && buffer && bytes >= 0) {
+    size_t count = fwrite(buffer, 1, (size_t) bytes, self->fh);
+    if (!ferror(self->fh)) return (int) count;
+  }
+  return -1;
+}
+
+static int msp_seek(struct mspack_file *file, off_t offset, int mode) {
+  struct mspack_file_p *self = (struct mspack_file_p *) file;
+  if (self) {
+    switch (mode) {
+    case MSPACK_SYS_SEEK_START: mode = SEEK_SET; break;
+    case MSPACK_SYS_SEEK_CUR:   mode = SEEK_CUR; break;
+    case MSPACK_SYS_SEEK_END:   mode = SEEK_END; break;
+    default: return -1;
+    }
+#if HAVE_FSEEKO
+    return fseeko(self->fh, offset, mode);
+#else
+    return fseek(self->fh, offset, mode);
+#endif
+  }
+  return -1;
+}
+
+static off_t msp_tell(struct mspack_file *file) {
+  struct mspack_file_p *self = (struct mspack_file_p *) file;
+#if HAVE_FSEEKO
+  return (self) ? (off_t) ftello(self->fh) : 0;
+#else
+  return (self) ? (off_t) ftell(self->fh) : 0;
+#endif
+}
+
+static void msp_msg(struct mspack_file *file, const char *format, ...) {
+  va_list ap;
+  if (file) fprintf(stderr, "%s: ", ((struct mspack_file_p *) file)->name);
+  va_start(ap, format);
+  vfprintf(stderr, format, ap);
+  va_end(ap);
+  fputc((int) '\n', stderr);
+  fflush(stderr);
+}
+
+static void *msp_alloc(struct mspack_system *self, size_t bytes) {
+#if DEBUG
+  /* make uninitialised data obvious */
+  char *buf = malloc(bytes + 8);
+  if (buf) memset(buf, 0xDC, bytes);
+  *((size_t *)buf) = bytes;
+  return &buf[8];
+#else
+  return malloc(bytes);
+#endif
+}
+
+static void msp_free(void *buffer) {
+#if DEBUG
+  char *buf = buffer;
+  size_t bytes;
+  if (buf) {
+    buf -= 8;
+    bytes = *((size_t *)buf);
+    /* make freed data obvious */
+    memset(buf, 0xED, bytes);
+    free(buf);
+  }
+#else
+  free(buffer);
+#endif
+}
+
+static void msp_copy(void *src, void *dest, size_t bytes) {
+  memcpy(dest, src, bytes);
+}
+
+static struct mspack_system msp_system = {
+  &msp_open, &msp_close, &msp_read,  &msp_write, &msp_seek,
+  &msp_tell, &msp_msg, &msp_alloc, &msp_free, &msp_copy, NULL
+};
+
+struct mspack_system *mspack_default_system = &msp_system;
+
+#endif
diff --git a/third_party/mspack/system.h b/third_party/mspack/system.h
new file mode 100644
index 000000000..826e89f3e
--- /dev/null
+++ b/third_party/mspack/system.h
@@ -0,0 +1,113 @@
+/* This file is part of libmspack.
+ * (C) 2003-2018 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_SYSTEM_H
+#define MSPACK_SYSTEM_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ensure config.h is read before mspack.h */
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <mspack.h>
+
+/* assume <string.h> exists */
+#include <string.h>
+
+/* fix for problem with GCC 4 and glibc (thanks to Ville Skytta)
+ * http://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=150429
+ */
+#ifdef read
+# undef read
+#endif
+
+/* Old GCCs don't have __func__, but __FUNCTION__:
+ * http://gcc.gnu.org/onlinedocs/gcc/Function-Names.html
+ */
+#if __STDC_VERSION__ < 199901L
+# if __GNUC__ >= 2
+#  define __func__ __FUNCTION__
+# else
+#  define __func__ "<unknown>"
+# endif
+#endif
+
+#if DEBUG
+# include <stdio.h>
+# define D(x) do { printf("%s:%d (%s) ",__FILE__, __LINE__, __func__); \
+                   printf x ; fputc('\n', stdout); fflush(stdout);} while (0);
+#else
+# define D(x)
+#endif
+
+/* CAB supports searching through files over 4GB in size, and the CHM file
+ * format actively uses 64-bit offsets. These can only be fully supported
+ * if the system the code runs on supports large files. If not, the library
+ * will work as normal using only 32-bit arithmetic, but if an offset
+ * greater than 2GB is detected, an error message indicating the library
+ * can't support the file should be printed.
+ */
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# define PRId64 "lld"
+# define PRIu64 "llu"
+# define PRId32 "ld"
+# define PRIu32 "lu"
+#endif
+
+#include <limits.h>
+#if ((defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS >= 64) || \
+     (defined(FILESIZEBITS)      && FILESIZEBITS      >= 64) || \
+     defined(_LARGEFILE_SOURCE) || defined(_LARGEFILE64_SOURCE) || \
+     SIZEOF_OFF_T >= 8)
+# define LARGEFILE_SUPPORT 1
+# define LD PRId64
+# define LU PRIu64
+#else
+extern const char *largefile_msg;
+# define LD PRId32
+# define LU PRIu32
+#endif
+
+/* endian-neutral reading of little-endian data */
+#define __egi32(a,n) ( ((((unsigned char *) a)[n+3]) << 24) | \
+                       ((((unsigned char *) a)[n+2]) << 16) | \
+                       ((((unsigned char *) a)[n+1]) <<  8) | \
+                       ((((unsigned char *) a)[n+0])))
+#define EndGetI64(a) ((((unsigned long long int) __egi32(a,4)) << 32) | \
+                      ((unsigned int) __egi32(a,0)))
+#define EndGetI32(a) __egi32(a,0)
+#define EndGetI16(a) ((((a)[1])<<8)|((a)[0]))
+
+/* endian-neutral reading of big-endian data */
+#define EndGetM32(a) (((((unsigned char *) a)[0]) << 24) | \
+                      ((((unsigned char *) a)[1]) << 16) | \
+                      ((((unsigned char *) a)[2]) <<  8) | \
+                      ((((unsigned char *) a)[3])))
+#define EndGetM16(a) ((((a)[0])<<8)|((a)[1]))
+
+extern struct mspack_system *mspack_default_system;
+
+/* returns the length of a file opened for reading */
+extern int mspack_sys_filelen(struct mspack_system *system,
+                              struct mspack_file *file, off_t *length);
+
+/* validates a system structure */
+extern int mspack_valid_system(struct mspack_system *sys);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/third_party/xbyak b/third_party/xbyak
index 08f767527..bc70e7e11 160000
--- a/third_party/xbyak
+++ b/third_party/xbyak
@@ -1 +1 @@
-Subproject commit 08f767527377ef3e2a6e0133c26921d138cf87f7
+Subproject commit bc70e7e11ad37f207ece73330c5b72a55fef1ceb
diff --git a/tools/shader-playground/README.md b/tools/shader-playground/README.md
index 1c8fe7e6a..559b22b7e 100644
--- a/tools/shader-playground/README.md
+++ b/tools/shader-playground/README.md
@@ -1,5 +1,5 @@
 This requires XNA Game Studio 3.1 to be installed (not just the redist):
-http://www.microsoft.com/en-us/download/details.aspx?id=39
+https://www.microsoft.com/en-us/download/details.aspx?id=39
 
 It's not really compatible with modern VS', but you can open the downloaded
 `XNAGS31_setup.exe` with 7zip and run the included `redists.msi` directly.
diff --git a/xenia-build b/xenia-build
index fde577e8b..6fd59ed4d 100755
--- a/xenia-build
+++ b/xenia-build
@@ -304,7 +304,7 @@ def get_clang_format_binary():
         if has_bin(binary):
             return binary
     print('ERROR: clang-format is not on PATH')
-    print('LLVM is available from http://llvm.org/releases/download.html')
+    print('LLVM is available from https://llvm.org/releases/download.html')
     print('At least version 3.8 is required.')
     print('See docs/style_guide.md for instructions on how to get it.')
     sys.exit(1)
@@ -708,6 +708,7 @@ class GenSpirvCommand(Command):
             # GLSL source -> .spv binary
             shell_call([
                 glslang,
+                '-Os',
                 '-V', src_file,
                 '-o', spv_file,
                 ])